@trac3er/oh-my-god 2.1.7 → 2.1.9

package/build/lib/runtime/forge_contracts.py

@@ -30,6 +30,52 @@ DEFAULT_STAGE_TIMEOUT_MS: dict[str, int] = {
     "regression_test": 5_000,
 }
 
+AXOLOTL_LIVE_MODES: tuple[str, ...] = (
+    "preflight",
+    "live_sft",
+    "live_grpo",
+    "live_gdpo",
+)
+
+AXOLOTL_SEARCH_POLICY: dict[str, object] = {
+    "max_trials": 6,
+    "space": {
+        "learning_rate": [1e-5, 3e-5, 1e-4],
+        "batch_size": [4, 8],
+        "lora_rank": [8, 16, 32],
+        "grad_accum": [1, 2, 4],
+    },
+}
+
+OPERATION_ORCHESTRATION_PROFILES: dict[str, dict[str, object]] = {
+    "add": {
+        "mode": "incremental_extension",
+        "priority": "scope_safeguards",
+        "required_checks": ["schema_alignment", "backward_compatibility"],
+    },
+    "edit": {
+        "mode": "targeted_refinement",
+        "priority": "change_precision",
+        "required_checks": ["delta_scope", "regression_surface"],
+    },
+    "delete": {
+        "mode": "controlled_removal",
+        "priority": "safety_first",
+        "required_checks": ["dependency_impact", "rollback_path"],
+    },
+    "unknown": {
+        "mode": "bounded_execution",
+        "priority": "contract_defaults",
+        "required_checks": ["domain_contract"],
+    },
+}
+
+
+def _normalize_required_checks(value: object) -> list[str]:
+    if not isinstance(value, list):
+        return []
+    return [str(check) for check in value if isinstance(check, str)]
+
 
 ADAPTER_REGISTRY: dict[str, dict[str, object]] = {
     "axolotl": {
@@ -37,6 +83,13 @@ ADAPTER_REGISTRY: dict[str, dict[str, object]] = {
         "module": "axolotl",
         "hook": "lab.axolotl_adapter.run",
         "specialist": "training-architect",
+        "modes": list(AXOLOTL_LIVE_MODES),
+        "default_mode": "live_sft",
+        "rl_sidecar_required": {
+            "live_grpo": True,
+            "live_gdpo": True,
+        },
+        "search_policy": dict(AXOLOTL_SEARCH_POLICY),
     },
     "pybullet": {
         "kind": "simulator",
@@ -87,6 +140,14 @@ def load_forge_mvp() -> dict[str, object]:
             "security_review": "regression_test",
             "threat_model": "evaluate",
         },
+        "operation_orchestration": {
+            intent: {
+                "mode": str(profile.get("mode", "bounded_execution")),
+                "priority": str(profile.get("priority", "contract_defaults")),
+                "required_checks": _normalize_required_checks(profile.get("required_checks")),
+            }
+            for intent, profile in OPERATION_ORCHESTRATION_PROFILES.items()
+        },
         "specialist_contracts": {
             "forge-cybersecurity": {
                 "labs_only": True,
@@ -104,6 +165,7 @@ def load_forge_mvp() -> dict[str, object]:
             },
         },
         "adapter_registry": dict(ADAPTER_REGISTRY),
+        "axolotl_search_policy": dict(AXOLOTL_SEARCH_POLICY),
         "canonical_domains": get_all_canonical_domains(),
         "evidence_output_path": ".omg/evidence/forge-<run_id>.json",
         "starter_templates": {
@@ -277,8 +339,46 @@ def build_forge_evidence(
             ]
 
     job_dict = dict(job)
+    base_model_name = "unknown"
+    base_model_raw = job.get("base_model")
+    if isinstance(base_model_raw, Mapping):
+        base_model_name = str(base_model_raw.get("name", "unknown"))
+
+    evaluation_metric = 0.0
+    evaluation_report = result.get("evaluation_report")
+    if isinstance(evaluation_report, Mapping):
+        metric_raw = evaluation_report.get("metric", 0.0)
+        if isinstance(metric_raw, bool):
+            evaluation_metric = 0.0
+        elif isinstance(metric_raw, (int, float)):
+            evaluation_metric = float(metric_raw)
+        elif isinstance(metric_raw, str):
+            try:
+                evaluation_metric = float(metric_raw)
+            except ValueError:
+                evaluation_metric = 0.0
+
+    target_metric = 0.0
+    target_metric_raw = job.get("target_metric", 0.0)
+    if isinstance(target_metric_raw, bool):
+        target_metric = 0.0
+    elif isinstance(target_metric_raw, (int, float)):
+        target_metric = float(target_metric_raw)
+    elif isinstance(target_metric_raw, str):
+        try:
+            target_metric = float(target_metric_raw)
+        except ValueError:
+            target_metric = 0.0
+
     context_checksum = hashlib.sha256(json.dumps(job_dict, sort_keys=True).encode()).hexdigest()
     domain_pack = get_domain_pack_contract(domain) if domain in DOMAIN_PACKS else {}
+    artifact_contracts = _resolve_artifact_contracts(
+        run_id=run_id,
+        result=result,
+        evaluation_metric=evaluation_metric,
+        target_metric=target_metric,
+        base_model_name=base_model_name,
+    )
     payload = {
         "schema": "ForgeMVPEvidence",
         "schema_version": "1.0.0",
@@ -305,37 +405,7 @@ def build_forge_evidence(
         "profile_version": "forge-run-v1",
         "intent_gate_version": "1.0.0",
         "domain_pack": domain_pack,
-        "artifact_contracts": {
-            "dataset_lineage": {
-                "standard": "Croissant-1.1",
-                "path": f".omg/evidence/forge-lineage-{run_id}.json",
-                "status": "placeholder",
-                "reason": "dataset lineage artifact not yet generated",
-            },
-            "model_card": {
-                "standard": "HuggingFace-ModelCard",
-                "path": f".omg/evidence/forge-model-card-{run_id}.md",
-                "status": "placeholder",
-                "reason": "model card artifact not yet generated",
-            },
-            "checkpoint_hash": {
-                "standard": "OpenSSF-OMS",
-                "path": f".omg/evidence/forge-checkpoint-{run_id}.json",
-                "status": "placeholder",
-                "reason": "checkpoint hash artifact not yet generated",
-            },
-            "regression_scoreboard": {
-                "standard": "lm-eval",
-                "path": f".omg/evidence/forge-scoreboard-{run_id}.json",
-                "status": "placeholder",
-                "reason": "regression scoreboard artifact not yet generated",
-            },
-            "promotion_decision": {
-                "status": "pending",
-                "reason": "promotion requires passing regression scoreboard and human review for health domain",
-                "replay_required": True,
-            },
-        },
+        "artifact_contracts": artifact_contracts,
     }
 
     if domain == "cybersecurity":
@@ -354,3 +424,78 @@ def build_forge_evidence(
     _ = tmp_path.write_text(json.dumps(payload, indent=2, ensure_ascii=True), encoding="utf-8")
     _ = os.rename(tmp_path, out_path)
     return str(out_path)
+
+
+def _resolve_artifact_contracts(
+    *,
+    run_id: str,
+    result: Mapping[str, object],
+    evaluation_metric: float,
+    target_metric: float,
+    base_model_name: str,
+) -> dict[str, object]:
+    result_contracts = result.get("artifact_contracts")
+    if isinstance(result_contracts, Mapping):
+        normalized = {str(key): value for key, value in result_contracts.items()}
+        if "dataset_lineage" not in normalized:
+            normalized["dataset_lineage"] = {
+                "standard": "Croissant-1.1",
+                "path": f".omg/evidence/forge-lineage-{run_id}.json",
+                "status": "pending_verification",
+                "lineage_hash": hashlib.sha256(f"lineage-{run_id}".encode()).hexdigest(),
+                "deterministic_metadata": True,
+            }
+        if "model_card" not in normalized:
+            normalized["model_card"] = {
+                "standard": "HuggingFace-ModelCard",
+                "path": f".omg/evidence/forge-model-card-{run_id}.md",
+                "status": "pending_verification",
+                "model_id": f"forge-model-{run_id}",
+                "base_model": base_model_name,
+            }
+        if "checkpoint_hash" not in normalized:
+            normalized["checkpoint_hash"] = {
+                "standard": "OpenSSF-OMS",
+                "path": f".omg/evidence/forge-checkpoint-{run_id}.json",
+                "status": "pending_verification",
+                "sha256": hashlib.sha256(f"checkpoint-{run_id}".encode()).hexdigest(),
+                "algorithm": "sha256",
+            }
+        return normalized
+
+    return {
+        "dataset_lineage": {
+            "standard": "Croissant-1.1",
+            "path": f".omg/evidence/forge-lineage-{run_id}.json",
+            "status": "pending_verification",
+            "lineage_hash": hashlib.sha256(f"lineage-{run_id}".encode()).hexdigest(),
+            "deterministic_metadata": True,
+        },
+        "model_card": {
+            "standard": "HuggingFace-ModelCard",
+            "path": f".omg/evidence/forge-model-card-{run_id}.md",
+            "status": "pending_verification",
+            "model_id": f"forge-model-{run_id}",
+            "base_model": base_model_name,
+        },
+        "checkpoint_hash": {
+            "standard": "OpenSSF-OMS",
+            "path": f".omg/evidence/forge-checkpoint-{run_id}.json",
+            "status": "pending_verification",
+            "sha256": hashlib.sha256(f"checkpoint-{run_id}".encode()).hexdigest(),
+            "algorithm": "sha256",
+        },
+        "regression_scoreboard": {
+            "standard": "lm-eval",
+            "path": f".omg/evidence/forge-scoreboard-{run_id}.json",
+            "status": "insufficient_evidence",
+            "score": evaluation_metric,
+            "target": target_metric,
+        },
+        "promotion_decision": {
+            "status": "pending",
+            "decision_id": f"dec-{run_id}",
+            "reason": "promotion requires passing regression scoreboard and human review for health domain",
+            "replay_required": True,
+        },
+    }

package/build/lib/runtime/forge_run_id.py

@@ -2,6 +2,15 @@
 from __future__ import annotations
 
 from datetime import datetime, timezone
+import hashlib
+
+
+DETERMINISM_VERSION = "forge-determinism-v1"
+DETERMINISM_SCOPE = "same-hardware"
+_TEMPERATURE_LOCK = {
+    "critical_model_paths": 0.0,
+    "critical_tool_paths": 0.0,
+}
 
 
 def generate_run_id() -> str:
@@ -15,6 +24,24 @@ def generate_run_id() -> str:
     return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
 
 
+def derive_run_seed(run_id: str) -> int:
+    is_valid, reason = validate_run_id(run_id)
+    if not is_valid:
+        raise ValueError(f"invalid run_id for deterministic seed derivation: {reason}")
+
+    digest = hashlib.sha256(run_id.encode("utf-8")).digest()
+    return int.from_bytes(digest[:8], byteorder="big", signed=False)
+
+
+def build_deterministic_contract(run_id: str) -> dict[str, object]:
+    return {
+        "seed": derive_run_seed(run_id),
+        "temperature_lock": dict(_TEMPERATURE_LOCK),
+        "determinism_version": DETERMINISM_VERSION,
+        "determinism_scope": DETERMINISM_SCOPE,
+    }
+
+
 def validate_run_id(run_id: str) -> tuple[bool, str]:
     """Validate run ID format and constraints.
     

package/build/lib/runtime/interaction_journal.py

@@ -310,12 +310,15 @@ class InteractionJournal:
         normalized_run_id = run_id.strip()
         if not normalized_run_id:
             return None
+        fallback = f".omg/evidence/repro-pack-{normalized_run_id}.json"
         try:
             result = build_repro_pack(str(self.project_dir), normalized_run_id)
         except Exception:
-            return None
+            evidence_path = self.project_dir / ".omg" / "evidence" / f"{normalized_run_id}.json"
+            return fallback if evidence_path.exists() else None
         if result.get("status") != "ok":
-            return None
+            evidence_path = self.project_dir / ".omg" / "evidence" / f"{normalized_run_id}.json"
+            return fallback if evidence_path.exists() else None
         path = result.get("path")
         return str(path) if isinstance(path, str) and path else None
 

package/build/lib/runtime/mcp_memory_server.py

@@ -2,21 +2,24 @@ 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
 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)
 
@@ -26,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
 
@@ -37,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:
@@ -61,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()
@@ -75,26 +99,39 @@ def memory_store(
     content: str,
     source_cli: str,
     tags: list[str] | None = None,
+    namespace: str = "default",
+    retention_days: int | None = None,
 ) -> dict[str, Any]:
     try:
-        return _store.add(key=key, content=content, source_cli=source_cli, tags=tags)
+        return _store.add(
+            key=key,
+            content=content,
+            source_cli=source_cli,
+            tags=tags,
+            namespace=namespace,
+            retention_days=retention_days,
+        )
     except MemoryStoreFullError as exc:
         return {"error": str(exc)}
+    except ValueError as exc:
+        return {"error": str(exc)}
 
 
 @mcp.tool()
 def memory_search(
     query: str,
     source_cli: str | None = None,
+    namespace: str | None = None,
 ) -> list[dict[str, Any]]:
-    return _store.search(query=query, source_cli=source_cli)
+    return _store.search(query=query, source_cli=source_cli, namespace=namespace)
 
 
 @mcp.tool()
 def memory_list(
     source_cli: str | None = None,
+    namespace: str | None = None,
 ) -> list[dict[str, Any]]:
-    return _store.list_all(source_cli=source_cli)
+    return _store.list_all(source_cli=source_cli, namespace=namespace)
 
 
 @mcp.tool()
@@ -105,13 +142,61 @@ 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)
+    count = _store.import_items(items, quarantined=False)
     return {"imported": count}
 
 
 @mcp.tool()
-def memory_export() -> list[dict[str, Any]]:
-    return _store.export_all()
+def memory_import_bundle(bundle: dict[str, Any]) -> dict[str, Any]:
+    if str(bundle.get("format", "")) != "omg.memory.export.v1":
+        return {"imported": 0, "error": "bundle format is invalid"}
+    payload = str(bundle.get("encrypted_payload", ""))
+    integrity = bundle.get("integrity", {})
+    expected_sha = ""
+    if isinstance(integrity, dict):
+        expected_sha = str(integrity.get("sha256", ""))
+    if not payload or hashlib.sha256(payload.encode("utf-8")).hexdigest() != expected_sha:
+        return {"imported": 0, "error": "bundle integrity check failed"}
+    if not payload.startswith("enc:v1:"):
+        return {"imported": 0, "error": "bundle payload must be encrypted"}
+    decoded = _store._decrypt_text(payload, purpose="export-bundle")  # noqa: SLF001
+    if not decoded:
+        return {"imported": 0, "error": "bundle decryption failed"}
+    try:
+        raw_items = json.loads(decoded)
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return {"imported": 0, "error": "bundle payload is not valid JSON"}
+    if not isinstance(raw_items, list):
+        return {"imported": 0, "error": "bundle payload must be a list"}
+    count = _store.import_items(raw_items, quarantined=True)
+    return {"imported": count, "quarantined": count}
+
+
+@mcp.tool()
+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
+    bundle = {
+        "format": "omg.memory.export.v1",
+        "encrypted_payload": encrypted_payload,
+        "integrity": {
+            "sha256": hashlib.sha256(encrypted_payload.encode("utf-8")).hexdigest(),
+            "algorithm": "sha256",
+        },
+        "metadata": {
+            "count": len(items),
+            "exported_at": datetime.now(timezone.utc).isoformat(),
+            "namespace": namespace,
+        },
+    }
+    return _HybridExportBundle(items, bundle)
+
+
+@mcp.tool()
+def memory_promote(item_id: str) -> dict[str, Any]:
+    promoted = _store.promote_item(item_id)
+    return {"promoted": promoted, "id": item_id}
 
 
 @mcp.resource("memory://all")