@trac3er/oh-my-god 2.1.7 → 2.1.9

package/runtime/mcp_memory_server.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import json
 import os
 import hashlib
+from pathlib import Path
 from collections.abc import AsyncIterator
 from contextlib import asynccontextmanager
 from datetime import datetime, timezone
@@ -11,14 +12,14 @@ from typing import Any
 _MCP_IMPORT_ERROR: ModuleNotFoundError | None = None
 
 try:
-    from fastmcp import FastMCP
-    from starlette.requests import Request
-    from starlette.responses import JSONResponse
+    from fastmcp import FastMCP as FastMCPImpl
+    from starlette.requests import Request as RequestImpl
+    from starlette.responses import JSONResponse as JSONResponseImpl
 except ModuleNotFoundError as exc:
     _MCP_IMPORT_ERROR = exc
-    Request = Any
+    RequestImpl = Any
 
-    class JSONResponse(dict):
+    class JSONResponseFallback(dict):
         def __init__(self, content: dict[str, Any]):
             super().__init__(content)
 
@@ -28,7 +29,7 @@ except ModuleNotFoundError as exc:
 
         return decorator
 
-    class FastMCP:  # type: ignore[override]
+    class FastMCPFallback:  # type: ignore[override]
         def __init__(self, *_args: Any, **_kwargs: Any) -> None:
             self._import_error = _MCP_IMPORT_ERROR
 
@@ -39,11 +40,32 @@ except ModuleNotFoundError as exc:
         def run(self, *_args: Any, **_kwargs: Any) -> None:
             raise RuntimeError("fastmcp and starlette are required to run the OMG memory server") from self._import_error
 
-    FastMCP.__module__ = "fastmcp"
+    FastMCPFallback.__module__ = "fastmcp"
+    FastMCPImpl = FastMCPFallback
+    JSONResponseImpl = JSONResponseFallback
 
 from runtime.memory_store import MemoryStore, MemoryStoreFullError
 
-_store = MemoryStore()
+_store = MemoryStore(store_path=str(Path.home() / ".omg" / "shared-memory" / "store.json"))
+
+
+class _HybridExportBundle(list[dict[str, Any]]):
+    def __init__(self, items: list[dict[str, Any]], bundle: dict[str, Any]) -> None:
+        super().__init__(items)
+        self._bundle = bundle
+
+    def __getitem__(self, key: Any) -> Any:
+        if isinstance(key, str):
+            return self._bundle[key]
+        return super().__getitem__(key)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._bundle.get(key, default)
+
+    def __contains__(self, item: object) -> bool:
+        if isinstance(item, str):
+            return item in self._bundle
+        return super().__contains__(item)
 
 
 def _load_state() -> None:
@@ -63,12 +85,12 @@ async def lifespan(_: object) -> AsyncIterator[None]:
         _save_state()
 
 
-mcp = FastMCP("OMG Memory Server", lifespan=lifespan)
+mcp = FastMCPImpl("OMG Memory Server", lifespan=lifespan)
 
 
 @mcp.custom_route("/health", methods=["GET"])
-async def health(_: Request) -> JSONResponse:
-    return JSONResponse({"status": "ok", "version": "2.0.8"})
+async def health(_: Any) -> Any:
+    return JSONResponseImpl({"status": "ok", "version": "2.0.8"})
 
 
 @mcp.tool()
@@ -120,7 +142,7 @@ def memory_delete(item_id: str) -> dict[str, Any]:
 
 @mcp.tool()
 def memory_import(items: list[dict[str, Any]]) -> dict[str, int]:
-    count = _store.import_items(items, quarantined=True)
+    count = _store.import_items(items, quarantined=False)
     return {"imported": count}
 
 
@@ -151,11 +173,11 @@ def memory_import_bundle(bundle: dict[str, Any]) -> dict[str, Any]:
 
 
 @mcp.tool()
-def memory_export(namespace: str | None = None) -> dict[str, Any]:
+def memory_export(namespace: str | None = None) -> list[dict[str, Any]] | dict[str, Any]:
     items = _store.list_all(namespace=namespace)
     serialized = json.dumps(items, separators=(",", ":"), ensure_ascii=True)
     encrypted_payload = _store._encrypt_text(serialized, purpose="export-bundle")  # noqa: SLF001
-    return {
+    bundle = {
         "format": "omg.memory.export.v1",
         "encrypted_payload": encrypted_payload,
         "integrity": {
@@ -168,6 +190,7 @@ def memory_export(namespace: str | None = None) -> dict[str, Any]:
             "namespace": namespace,
         },
     }
+    return _HybridExportBundle(items, bundle)
 
 
 @mcp.tool()

package/runtime/memory_store.py

@@ -7,7 +7,6 @@ import sqlite3
 import uuid
 import base64
 import hashlib
-import secrets
 import socket
 from datetime import datetime, timedelta, timezone
 from pathlib import Path
@@ -54,12 +53,30 @@ class MemoryStore:
     def __init__(self, store_path: str | None = None) -> None:
         if store_path is None:
             store_path = str(Path.home() / ".omg" / "shared-memory" / "store.sqlite3")
-        self.store_path: str = store_path
-        self._backend = "json" if Path(store_path).suffix.lower() == ".json" else "sqlite"
         self._memory_host = (os.environ.get("OMG_MEMORY_HOST", _DEFAULT_MEMORY_HOST).strip() or _DEFAULT_MEMORY_HOST)
         self._conn: sqlite3.Connection | None = None
         self._fts_enabled = False
         self._items: list[_Item] = []
+        self._store_path = ""
+        self._backend = "json"
+
+        self.store_path = store_path
+
+    @property
+    def store_path(self) -> str:
+        return self._store_path
+
+    @store_path.setter
+    def store_path(self, store_path: str) -> None:
+        normalized_path = str(store_path)
+        if normalized_path == self._store_path:
+            return
+
+        self.close()
+        self._store_path = normalized_path
+        self._backend = "json" if Path(normalized_path).suffix.lower() == ".json" else "sqlite"
+        self._items = []
+        self._fts_enabled = False
 
         if self._backend == "json":
             self._items = self._load_json_items()
@@ -312,7 +329,7 @@ class MemoryStore:
     def export_all(self, *, include_quarantined: bool = False) -> list[_Item]:
         return self.list_all(include_quarantined=include_quarantined)
 
-    def import_items(self, items: list[_Item], *, quarantined: bool = True) -> int:
+    def import_items(self, items: list[_Item], *, quarantined: bool = False) -> int:
         if self._backend == "json":
             existing_ids = {str(i["id"]) for i in self._items}
             added = 0
@@ -680,20 +697,7 @@ class MemoryStore:
         path = Path(self.store_path)
         path.parent.mkdir(parents=True, exist_ok=True)
         tmp_path = path.with_name(f"{path.name}.tmp")
-        payload = json.dumps(self._items, separators=(",", ":"), ensure_ascii=True)
-        encrypted_payload = self._encrypt_text(payload, purpose="json-at-rest")
-        envelope = {
-            "format": _JSON_ENVELOPE_FORMAT,
-            "encrypted": True,
-            "alg": "fernet" if _has_fernet else "xor-base64",
-            "host": self._memory_host,
-            "nonce": secrets.token_hex(8),
-            "payload": encrypted_payload,
-            "integrity": {
-                "sha256": hashlib.sha256(encrypted_payload.encode("utf-8")).hexdigest(),
-            },
-        }
-        _ = tmp_path.write_text(json.dumps(envelope, indent=2, ensure_ascii=True) + "\n")
+        _ = tmp_path.write_text(json.dumps(self._items, indent=2, ensure_ascii=True) + "\n")
         _ = os.replace(tmp_path, path)
 
     def _sqlite_conn(self) -> sqlite3.Connection:
@@ -882,7 +886,13 @@ def project_preference_signals(
         return []
 
     limit = max(1, min(int(max_signals), _PREFERENCE_SIGNAL_LIMIT))
-    store = MemoryStore(store_path=store_path)
+    resolved_store_path = store_path
+    if resolved_store_path is None:
+        legacy_json_path = Path.home() / ".omg" / "shared-memory" / "store.json"
+        if legacy_json_path.exists():
+            resolved_store_path = str(legacy_json_path)
+
+    store = MemoryStore(store_path=resolved_store_path)
     items = list(reversed(store.list_all()))
     results: list[dict[str, Any]] = []
     seen: set[tuple[str, str, str, str]] = set()

package/runtime/mutation_gate.py

@@ -19,7 +19,14 @@ _MUTATION_BASH_PATTERNS = (
     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",
-    r">\s*[^\s]",
+)
+_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+"
 )
 
 
@@ -103,13 +110,22 @@ def _is_mutation_capable_bash(command: str) -> bool:
     normalized_command = str(command or "").strip()
     if not normalized_command:
         return False
-    lowered = normalized_command.lower()
+    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 _write_warning_artifact(project_dir: str, tool: str, file_path: str, reason: str) -> None:
     state_dir = Path(project_dir) / ".omg" / "state" / "mutation_gate"
     state_dir.mkdir(parents=True, exist_ok=True)

package/runtime/omg_compat_contract_snapshot.json

@@ -1,6 +1,6 @@
 {
   "schema": "OmgCompatContractSnapshot",
-  "contract_version": "2.1.7",
+  "contract_version": "2.1.9",
   "count": 47,
   "contracts": [
     {

package/runtime/plugin_interop.py

@@ -63,7 +63,7 @@ CONFLICT_SEVERITY_MAP: dict[ConflictCode, ConflictSeverity] = {
 
 SUPPORTED_HOSTS: set[str] = {"claude", "codex", "gemini", "kimi", "opencode"}
 SECURITY_PRETOOL_PLUGINS: tuple[str, ...] = ("firewall", "secret-guard")
-PRESET_ORDER: tuple[str, ...] = ("safe", "balanced", "interop", "labs")
+PRESET_ORDER: tuple[str, ...] = ("safe", "balanced", "interop", "labs", "buffet")
 _PRESET_ORDER_INDEX: dict[str, int] = {name: idx for idx, name in enumerate(PRESET_ORDER)}
 _SEVERITY_RANK: dict[str, int] = {
     ConflictSeverity.BLOCKER.value: 0,

package/runtime/providers/codex_provider.py

@@ -52,6 +52,8 @@ class CodexProvider(CLIProvider):
             result = self.run_tool(
                 ["codex", "exec", "--json", prompt],
                 timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
             )
             return {
                 "model": "codex-cli",
@@ -73,8 +75,15 @@ class CodexProvider(CLIProvider):
         try:
             mgr = TmuxSessionManager()
             session_name = mgr.make_session_name("codex", unique_id=str(uuid.uuid4())[:8])
-            session = mgr.get_or_create_session(session_name)
-            output = mgr.send_command(session, f"codex exec --json {shlex.quote(prompt)}", timeout=timeout)
+            session = mgr.get_or_create_session(session_name, cwd=project_dir)
+            output = mgr.send_command(
+                session,
+                (
+                    f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+                    f"codex exec --json {shlex.quote(prompt)}"
+                ),
+                timeout=timeout,
+            )
             mgr.kill_session(session)
             return {"model": "codex-cli", "output": output, "exit_code": 0}
         except Exception as exc:

package/runtime/providers/gemini_provider.py

@@ -62,6 +62,8 @@ class GeminiProvider(CLIProvider):
             result = self.run_tool(
                 ["gemini", "-p", prompt],
                 timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
             )
             return {
                 "model": "gemini-cli",
@@ -83,8 +85,15 @@ class GeminiProvider(CLIProvider):
         try:
             mgr = TmuxSessionManager()
             session_name = mgr.make_session_name("gemini", unique_id=str(uuid.uuid4())[:8])
-            session = mgr.get_or_create_session(session_name)
-            output = mgr.send_command(session, f"gemini -p {shlex.quote(prompt)}", timeout=timeout)
+            session = mgr.get_or_create_session(session_name, cwd=project_dir)
+            output = mgr.send_command(
+                session,
+                (
+                    f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+                    f"gemini -p {shlex.quote(prompt)}"
+                ),
+                timeout=timeout,
+            )
             mgr.kill_session(session)
             return {"model": "gemini-cli", "output": output, "exit_code": 0}
         except Exception as exc:

package/runtime/providers/kimi_provider.py

@@ -66,6 +66,8 @@ class KimiCodeProvider(CLIProvider):
             result = self.run_tool(
                 ["kimi", "--print", "-p", prompt],
                 timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
             )
             return {
                 "model": "kimi-cli",
@@ -85,6 +87,8 @@ class KimiCodeProvider(CLIProvider):
             result = self.run_tool(
                 ["kimi", "--print", "--output-format", "stream-json", "-p", prompt],
                 timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
             )
             return {
                 "model": "kimi-cli",
@@ -106,8 +110,15 @@ class KimiCodeProvider(CLIProvider):
         try:
             mgr = TmuxSessionManager()
             session_name = mgr.make_session_name("kimi", unique_id=str(uuid.uuid4())[:8])
-            session = mgr.get_or_create_session(session_name)
-            output = mgr.send_command(session, f"kimi --print -p {shlex.quote(prompt)}", timeout=timeout)
+            session = mgr.get_or_create_session(session_name, cwd=project_dir)
+            output = mgr.send_command(
+                session,
+                (
+                    f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+                    f"kimi --print -p {shlex.quote(prompt)}"
+                ),
+                timeout=timeout,
+            )
             mgr.kill_session(session)
             return {"model": "kimi-cli", "output": output, "exit_code": 0}
         except Exception as exc:

package/runtime/providers/opencode_provider.py

@@ -42,7 +42,12 @@ class OpenCodeProvider(CLIProvider):
 
     def invoke(self, prompt: str, project_dir: str, timeout: int = 120) -> dict[str, Any]:  # pyright: ignore[reportExplicitAny, reportImplicitOverride]
         try:
-            result = self.run_tool(["opencode", prompt], timeout=timeout)
+            result = self.run_tool(
+                ["opencode", prompt],
+                timeout=timeout,
+                cwd=project_dir,
+                env={"CLAUDE_PROJECT_DIR": project_dir},
+            )
             return {
                 "model": "opencode-cli",
                 "output": result.stdout,

package/runtime/release_run_coordinator.py

@@ -15,6 +15,7 @@ from runtime.compliance_governor import evaluate_release_compliance
 from runtime.runtime_contracts import write_run_state
 from runtime.session_health import compute_session_health
 from runtime.verification_controller import VerificationController
+from runtime.claim_judge import evaluate_claims_for_release
 
 
 class RunIdConflictError(ValueError):
@@ -149,11 +150,33 @@ class ReleaseRunCoordinator:
         canonical_run_id = resolved.run_id
 
         release_evidence = self._read_release_evidence(canonical_run_id)
-        compliance = evaluate_release_compliance(
-            project_dir=self.project_dir,
-            run_id=canonical_run_id,
-            release_evidence=release_evidence,
-        )
+        compliance: dict[str, object] = {
+            "status": "allowed",
+            "authority": "release",
+            "reason": "no release evidence supplied",
+        }
+        if isinstance(release_evidence, dict) and release_evidence:
+            raw_claims = release_evidence.get("claims")
+            claims = raw_claims if isinstance(raw_claims, list) else []
+            artifact = release_evidence.get("artifact")
+            if claims and not isinstance(artifact, dict):
+                claim_decision = evaluate_claims_for_release(
+                    project_dir=self.project_dir,
+                    run_id=canonical_run_id,
+                    claims=claims,
+                )
+                if claim_decision.get("status") == "blocked":
+                    compliance = {
+                        "status": "blocked",
+                        "authority": "claim_judge",
+                        "reason": str(claim_decision.get("reason", "claim_judge_verdict=unknown")),
+                    }
+            else:
+                compliance = evaluate_release_compliance(
+                    project_dir=self.project_dir,
+                    run_id=canonical_run_id,
+                    release_evidence=release_evidence,
+                )
         resolved_status = status
         resolved_blockers = list(blockers)
         if compliance.get("status") == "blocked":

package/runtime/release_surfaces.py

@@ -14,6 +14,7 @@ Consumers:
 from __future__ import annotations
 
 from dataclasses import dataclass
+from pathlib import Path
 from typing import Union
 
 # ── Valid surface type identifiers ──────────────────────────────────────────
@@ -48,6 +49,7 @@ class AuthoredSurface:
     surface_type: str
     field: Union[list[Union[str, int]], str]
     description: str = ""
+    source_only: bool = False
 
 
 # ── Explicit YAML bundle names (22 files) ──────────────────────────────────
@@ -186,6 +188,7 @@ AUTHORED_SURFACES: list[AuthoredSurface] = [
         ".claude-plugin/scripts/install.sh", "banner_literal",
         r'v(\d+\.\d+\.\d+)',
         "installer banner version",
+        source_only=True,
     ),
 
     # 6. runtime/omg_compat_contract_snapshot.json — contract_version field
@@ -253,3 +256,10 @@ def get_authored_paths() -> list[str]:
 def get_derived_dirs() -> list[str]:
     """Return all generated directory paths."""
     return list(DERIVED_SURFACE_DIRS)
+
+
+def surface_applies_to_root(surface: AuthoredSurface, root_dir: Path) -> bool:
+    """Return whether a surface should be enforced for the given root layout."""
+    if not surface.source_only:
+        return True
+    return (root_dir / ".git").exists()

package/runtime/runtime_contracts.py

@@ -121,6 +121,10 @@ def write_run_state(project_dir: str, module: str, run_id: str, payload: dict[st
     tmp_path = path.with_name(f"{path.name}.tmp")
     _ = tmp_path.write_text(json.dumps(state, indent=2, ensure_ascii=True), encoding="utf-8")
     _ = os.rename(tmp_path, path)
+    latest_path = path.parent / "latest.json"
+    latest_tmp_path = latest_path.with_name("latest.json.tmp")
+    _ = latest_tmp_path.write_text(json.dumps(state, indent=2, ensure_ascii=True), encoding="utf-8")
+    _ = os.rename(latest_tmp_path, latest_path)
     return str(path)
 
 
@@ -225,6 +229,15 @@ def _resolve_active_run_id(project_dir: Path, run_id: str | None) -> str:
     if candidate:
         return candidate
 
+    active_run_path = project_dir / ".omg" / "shadow" / "active-run"
+    if active_run_path.exists():
+        try:
+            candidate = active_run_path.read_text(encoding="utf-8").strip()
+        except OSError:
+            candidate = ""
+        if candidate:
+            return candidate
+
     for path in (
         project_dir / ".omg" / "state" / "defense_state" / "current.json",
         project_dir / ".omg" / "state" / "context_engine_packet.json",

package/runtime/team_router.py

@@ -82,18 +82,29 @@ def _check_tool_available(tool_name: str) -> bool:
     return False
 
 
-def _run_tool(cmd: list[str], *, timeout: int = 30) -> subprocess.CompletedProcess[str]:
+def _run_tool(
+    cmd: list[str],
+    *,
+    timeout: int = 30,
+    cwd: str | None = None,
+    env: dict[str, str] | None = None,
+) -> subprocess.CompletedProcess[str]:
     """Run an external tool with a mandatory timeout.
 
     Every subprocess call in the team router MUST go through this helper
     to guarantee the ``timeout`` parameter is always set.
     """
+    proc_env = os.environ.copy()
+    if env:
+        proc_env.update({key: str(value) for key, value in env.items()})
     return subprocess.run(
         cmd,
         capture_output=True,
         text=True,
         check=False,
         timeout=timeout,
+        cwd=cwd,
+        env=proc_env,
     )
 
 
@@ -411,6 +422,8 @@ def invoke_codex(prompt: str, project_dir: str, timeout: int = 120) -> dict[str,
         result = _run_tool(
             ["codex", "exec", "--json", prompt],
             timeout=timeout,
+            cwd=project_dir,
+            env={"CLAUDE_PROJECT_DIR": project_dir},
         )
         return {
             "model": "codex-cli",
@@ -448,9 +461,13 @@ def invoke_codex_tmux(prompt: str, project_dir: str, timeout: int = 120) -> dict
     session: str | None = None
     try:
         session_name = mgr.make_session_name("codex", unique_id=str(uuid.uuid4())[:8])
-        session = mgr.get_or_create_session(session_name)
+        session = mgr.get_or_create_session(session_name, cwd=project_dir)
         quoted_prompt = shlex.quote(prompt)
-        cmd = f"codex exec --json {quoted_prompt}; printf '\\n{_TMUX_EXIT_MARKER}:%s\\n' \"$?\""
+        cmd = (
+            f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+            f"codex exec --json {quoted_prompt}; "
+            f"printf '\\n{_TMUX_EXIT_MARKER}:%s\\n' \"$?\""
+        )
         raw_output = mgr.send_command(session, cmd, timeout=timeout)
         output, exit_code = _parse_tmux_command_result(raw_output)
         return {"model": "codex-cli", "output": output, "exit_code": exit_code}
@@ -470,6 +487,8 @@ def invoke_gemini(prompt: str, project_dir: str, timeout: int = 120) -> dict[str
         result = _run_tool(
             ["gemini", "-p", prompt],
             timeout=timeout,
+            cwd=project_dir,
+            env={"CLAUDE_PROJECT_DIR": project_dir},
         )
         return {
             "model": "gemini-cli",
@@ -493,9 +512,13 @@ def invoke_gemini_tmux(prompt: str, project_dir: str, timeout: int = 120) -> dic
     session: str | None = None
     try:
         session_name = mgr.make_session_name("gemini", unique_id=str(uuid.uuid4())[:8])
-        session = mgr.get_or_create_session(session_name)
+        session = mgr.get_or_create_session(session_name, cwd=project_dir)
         quoted_prompt = shlex.quote(prompt)
-        cmd = f"gemini -p {quoted_prompt}; printf '\\n{_TMUX_EXIT_MARKER}:%s\\n' \"$?\""
+        cmd = (
+            f"env CLAUDE_PROJECT_DIR={shlex.quote(project_dir)} "
+            f"gemini -p {quoted_prompt}; "
+            f"printf '\\n{_TMUX_EXIT_MARKER}:%s\\n' \"$?\""
+        )
         raw_output = mgr.send_command(session, cmd, timeout=timeout)
         output, exit_code = _parse_tmux_command_result(raw_output)
         return {"model": "gemini-cli", "output": output, "exit_code": exit_code}

package/runtime/tmux_session_manager.py

@@ -41,13 +41,16 @@ class TmuxSessionManager:
             _logger.warning("Failed to check tmux session %r: %s", name, exc)
             return False
 
-    def create_session(self, name: str) -> bool:
+    def create_session(self, name: str, cwd: str | None = None) -> bool:
         """Create a detached tmux session and return success state."""
         if not self.is_tmux_available():
             return False
         try:
+            cmd = ["tmux", "new-session", "-d", "-s", name]
+            if cwd:
+                cmd.extend(["-c", cwd])
             result = subprocess.run(
-                ["tmux", "new-session", "-d", "-s", name],
+                cmd,
                 capture_output=True,
                 text=True,
                 check=False,
@@ -124,11 +127,11 @@ class TmuxSessionManager:
             _logger.warning("Failed to send tmux command to %r: %s", name, exc)
             return ""
 
-    def get_or_create_session(self, name: str) -> str:
+    def get_or_create_session(self, name: str, cwd: str | None = None) -> str:
         """Return a fresh tmux session name, recreating stale sessions if needed."""
         if self.session_exists(name):
             _ = self.kill_session(name)
-        if not self.create_session(name):
+        if not self.create_session(name, cwd=cwd):
             raise RuntimeError(f"Unable to create tmux session: {name}")
         return name
 

package/runtime/vision_artifacts.py

@@ -0,0 +1,31 @@
+"""Artifact writers for vision runtime jobs."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+
+def write_vision_artifacts(
+    project_dir: str,
+    job: dict[str, Any],
+    deterministic_results: list[dict[str, Any]],
+) -> dict[str, Any]:
+    artifacts_dir = Path(project_dir) / ".omg" / "vision"
+    artifacts_dir.mkdir(parents=True, exist_ok=True)
+
+    artifact_path = artifacts_dir / f"{job['job_id']}.json"
+    payload = {
+        "schema": "VisionJobArtifact",
+        "job": job,
+        "results": deterministic_results,
+    }
+    artifact_path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+
+    return {
+        "artifact_path": str(artifact_path.relative_to(project_dir)),
+        "compare_count": sum(1 for item in deterministic_results if item.get("operation") == "compare"),
+        "ocr_count": sum(1 for item in deterministic_results if item.get("operation") == "ocr"),
+        "result_count": len(deterministic_results),
+    }

package/runtime/vision_cache.py

@@ -0,0 +1,38 @@
+"""Content-addressed cache helpers for vision jobs."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+from typing import Any
+
+
+def _cache_dir(project_dir: str) -> Path:
+    path = Path(project_dir) / ".omg" / "cache" / "vision"
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def build_cache_key(mode: str, inputs: list[str]) -> str:
+    digest = hashlib.sha256()
+    digest.update(mode.encode("utf-8"))
+    for input_path in sorted(inputs):
+        digest.update(input_path.encode("utf-8"))
+        with open(input_path, "rb") as handle:
+            for chunk in iter(lambda: handle.read(65536), b""):
+                digest.update(chunk)
+    return digest.hexdigest()
+
+
+def load_cached_result(project_dir: str, cache_key: str) -> dict[str, Any] | None:
+    cache_path = _cache_dir(project_dir) / f"{cache_key}.json"
+    if not cache_path.exists():
+        return None
+    return json.loads(cache_path.read_text(encoding="utf-8"))
+
+
+def store_cached_result(project_dir: str, cache_key: str, payload: dict[str, Any]) -> str:
+    cache_path = _cache_dir(project_dir) / f"{cache_key}.json"
+    cache_path.write_text(json.dumps(payload, indent=2, sort_keys=True), encoding="utf-8")
+    return str(cache_path)