@trac3er/oh-my-god 2.1.1 → 2.1.4

package/build/lib/hooks/setup_wizard.py

@@ -7,7 +7,9 @@ from __future__ import annotations
 import json
 import logging
 import os
+import re
 import sys
+from pathlib import Path
 from typing import Any, cast
 
 import yaml
@@ -35,6 +37,7 @@ from runtime.mcp_config_writers import (  # noqa: E402
 import runtime.providers.codex_provider  # noqa: E402, F401
 import runtime.providers.gemini_provider  # noqa: E402, F401
 import runtime.providers.kimi_provider  # noqa: E402, F401
+from runtime.validate import run_validate as _run_post_install_validate  # noqa: E402
 from runtime.adoption import (  # noqa: E402
     CANONICAL_MODE_NAMES,
     CANONICAL_VERSION,
@@ -191,6 +194,28 @@ MCP_CATALOG: list[dict[str, Any]] = [
         "default": False,
         "category": "memory",
     },
+    {
+        "id": "notebooklm",
+        "name": "NotebookLM",
+        "description": "NotebookLM MCP server for AI-powered research and note-taking",
+        "command": "npx",
+        "args": ["-y", "notebooklm-mcp@latest"],
+        "default": False,
+        "category": "productivity",
+        "warning": (
+            "NOTEBOOKLM MCP WARNING\n\n"
+            "NotebookLM requires browser automation and has several important considerations:\n\n"
+            "BROWSER AUTOMATION: NotebookLM uses Puppeteer for browser automation. "
+            "This requires a Chromium/Chrome installation and may consume significant system resources.\n\n"
+            "FIRST-RUN DOWNLOAD: On first run, NotebookLM will download a full browser instance "
+            "(typically 100-300 MB). This is a one-time operation but may take several minutes.\n\n"
+            "DEDICATED ACCOUNT: It is strongly recommended to use a dedicated Google account "
+            "for NotebookLM MCP. Do NOT use your primary account, as the MCP will store credentials locally.\n\n"
+            "AUTH EXPIRY: Google authentication tokens expire periodically. "
+            "You may need to re-authenticate if the MCP fails with auth errors.\n\n"
+            "Enable NotebookLM only if you understand these requirements and accept the risks."
+        ),
+    },
 ]
 
 _MCP_ID_ALIASES: dict[str, str] = {
@@ -451,6 +476,12 @@ def check_auth() -> dict[str, Any]:
 
 _HTTP_MEMORY_MIN_LEVEL: int = _PRESET_LEVEL["interop"]
 
+_PROFILE_ARCH_REQUEST_MAX = 8
+_PROFILE_TAG_MAX = 12
+_PROFILE_SUMMARY_MAX_CHARS = 240
+_PROFILE_RECENT_UPDATES_MAX = 5
+_PROFILE_GOVERNED_MAX = 24
+
 
 def get_mode_choices() -> list[str]:
     return list(CANONICAL_MODE_NAMES)
@@ -660,6 +691,8 @@ def set_preferences(project_dir: str, preferences: dict[str, Any]) -> dict[str,
     state_dir = os.path.join(project_dir, ".omg", "state")
     os.makedirs(state_dir, exist_ok=True)
 
+    _write_profile_learning_sections(state_dir, preferences)
+
     # Write config to YAML file
     config_path = os.path.join(state_dir, "cli-config.yaml")
     with open(config_path, "w") as f:
@@ -674,6 +707,260 @@ def set_preferences(project_dir: str, preferences: dict[str, Any]) -> dict[str,
     }
 
 
+def _write_profile_learning_sections(state_dir: str, preferences: dict[str, Any]) -> None:
+    profile_path = os.path.join(state_dir, "profile.yaml")
+    profile_data = _load_profile_yaml(profile_path)
+    _ensure_profile_baseline(profile_data)
+
+    profile_data["preferences"] = _normalize_preferences_block(preferences.get("preferences"))
+    profile_data["user_vector"] = _normalize_user_vector_block(preferences.get("user_vector"))
+    profile_data["profile_provenance"] = _normalize_provenance_block(preferences.get("profile_provenance"))
+    profile_data["governed_preferences"] = _normalize_governed_preferences_block(preferences.get("governed_preferences"))
+
+    from runtime.profile_io import save_profile
+    save_profile(profile_path, profile_data)
+
+
+def _render_explicit_empty_collections(dumped: str) -> str:
+    lines = dumped.splitlines()
+    output: list[str] = []
+
+    def _next_line(start: int) -> str:
+        if start + 1 < len(lines):
+            return lines[start + 1]
+        return ""
+
+    for idx, line in enumerate(lines):
+        next_line = _next_line(idx)
+        stripped = line.strip()
+
+        if stripped == "stack:" and (not next_line or not next_line.startswith("- ")):
+            output.append("stack: []")
+            continue
+        if stripped == "conventions:" and (not next_line or not next_line.startswith("  ")):
+            output.append("conventions: {}")
+            continue
+        if stripped == "ai_behavior:" and (not next_line or not next_line.startswith("  ")):
+            output.append("ai_behavior: {}")
+            continue
+        if stripped == "architecture_requests:" and (not next_line or not next_line.startswith("    - ")):
+            output.append("  architecture_requests: []")
+            continue
+        if stripped == "constraints:" and (not next_line or not next_line.startswith("    ")):
+            output.append("  constraints: {}")
+            continue
+        if stripped == "tags:" and (not next_line or not next_line.startswith("    - ")):
+            output.append("  tags: []")
+            continue
+        if stripped == "recent_updates:" and (not next_line or not next_line.startswith("    - ")):
+            output.append("  recent_updates: []")
+            continue
+
+        output.append(line)
+
+    return "\n".join(output) + "\n"
+
+
+def _load_profile_yaml(profile_path: str) -> dict[str, Any]:
+    from runtime.profile_io import load_profile
+    return load_profile(profile_path)
+
+
+def _ensure_profile_baseline(profile_data: dict[str, Any]) -> None:
+    profile_data.setdefault("name", "omg-project")
+    profile_data.setdefault("description", "initialized by OMG standalone compat bootstrap")
+    profile_data.setdefault("language", "unknown")
+    profile_data.setdefault("framework", "unknown")
+    profile_data.setdefault("stack", [])
+    profile_data.setdefault("conventions", {})
+    profile_data.setdefault("ai_behavior", {})
+    profile_data.setdefault("governed_preferences", {"style": [], "safety": []})
+
+
+def _normalize_preferences_block(raw: Any) -> dict[str, Any]:
+    block = raw if isinstance(raw, dict) else {}
+
+    requests_obj = block.get("architecture_requests")
+    architecture_requests: list[str] = []
+    if isinstance(requests_obj, list):
+        for value in requests_obj:
+            text = str(value).strip()
+            if text:
+                architecture_requests.append(text)
+            if len(architecture_requests) >= _PROFILE_ARCH_REQUEST_MAX:
+                break
+
+    constraints_obj = block.get("constraints")
+    constraints: dict[str, Any] = {}
+    if isinstance(constraints_obj, dict):
+        for key, value in constraints_obj.items():
+            normalized_key = _normalize_constraint_key(str(key))
+            normalized_value = _normalize_constraint_value(value)
+            if normalized_key and normalized_value is not None:
+                constraints[normalized_key] = normalized_value
+
+    routing_obj = block.get("routing")
+    routing_map = routing_obj if isinstance(routing_obj, dict) else {}
+    routing = {
+        "prefer_clarification": bool(routing_map.get("prefer_clarification", False)),
+    }
+
+    return {
+        "architecture_requests": architecture_requests,
+        "constraints": constraints,
+        "routing": routing,
+    }
+
+
+def _normalize_constraint_key(value: str) -> str:
+    normalized = value.strip().lower()
+    normalized = re.sub(r"\s+", "_", normalized)
+    normalized = re.sub(r"[^a-z0-9_]+", "", normalized)
+    return normalized
+
+
+def _normalize_constraint_value(value: Any) -> str | int | float | bool | None:
+    if isinstance(value, bool):
+        return value
+    if isinstance(value, int):
+        return value
+    if isinstance(value, float):
+        return value
+    if value is None:
+        return None
+    text = str(value).strip().lower()
+    return text if text else None
+
+
+def _normalize_user_vector_block(raw: Any) -> dict[str, Any]:
+    block = raw if isinstance(raw, dict) else {}
+
+    tags_obj = block.get("tags")
+    tags: list[str] = []
+    if isinstance(tags_obj, list):
+        for value in tags_obj:
+            token = _normalize_tag_token(str(value))
+            if token:
+                tags.append(token)
+            if len(tags) >= _PROFILE_TAG_MAX:
+                break
+
+    summary = ""
+    summary_obj = block.get("summary")
+    if isinstance(summary_obj, str):
+        summary = " ".join(summary_obj.strip().split())[:_PROFILE_SUMMARY_MAX_CHARS]
+
+    confidence = 0.0
+    confidence_obj = block.get("confidence")
+    if isinstance(confidence_obj, (int, float, str)):
+        try:
+            confidence = float(confidence_obj)
+        except (TypeError, ValueError):
+            confidence = 0.0
+    confidence = max(0.0, min(1.0, confidence))
+
+    return {
+        "tags": tags,
+        "summary": summary,
+        "confidence": confidence,
+    }
+
+
+def _normalize_tag_token(value: str) -> str:
+    normalized = value.strip().lower()
+    normalized = re.sub(r"\s+", "_", normalized)
+    normalized = re.sub(r"[^a-z0-9_\-]+", "", normalized)
+    return normalized
+
+
+def _normalize_provenance_block(raw: Any) -> dict[str, Any]:
+    block = raw if isinstance(raw, dict) else {}
+    updates_obj = block.get("recent_updates")
+    updates: list[dict[str, str]] = []
+    if isinstance(updates_obj, list):
+        for entry in updates_obj:
+            if not isinstance(entry, dict):
+                continue
+            run_id = str(entry.get("run_id", "")).strip()
+            source = str(entry.get("source", "")).strip()
+            field = str(entry.get("field", "")).strip()
+            updated_at = str(entry.get("updated_at", "")).strip()
+            if not (run_id and source and field and updated_at):
+                continue
+            updates.append(
+                {
+                    "run_id": run_id,
+                    "source": source,
+                    "field": field,
+                    "updated_at": updated_at,
+                }
+            )
+            if len(updates) >= _PROFILE_RECENT_UPDATES_MAX:
+                break
+    return {"recent_updates": updates}
+
+
+def _normalize_governed_preferences_block(raw: Any) -> dict[str, list[dict[str, Any]]]:
+    block = raw if isinstance(raw, dict) else {}
+    style_raw = block.get("style")
+    safety_raw = block.get("safety")
+    return {
+        "style": _normalize_governed_section_entries(style_raw, section="style"),
+        "safety": _normalize_governed_section_entries(safety_raw, section="safety"),
+    }
+
+
+def _normalize_governed_section_entries(raw: Any, *, section: str) -> list[dict[str, Any]]:
+    if not isinstance(raw, list):
+        return []
+    entries: list[dict[str, Any]] = []
+    for item in raw:
+        if not isinstance(item, dict):
+            continue
+        field = str(item.get("field", "")).strip()
+        value = " ".join(str(item.get("value", "")).strip().split())
+        source = str(item.get("source", "")).strip()
+        learned_at = str(item.get("learned_at", "")).strip()
+        updated_at = str(item.get("updated_at", "")).strip()
+        candidate_section = str(item.get("section", section)).strip().lower()
+        confirmation_state = str(item.get("confirmation_state", "")).strip().lower()
+
+        if not (field and value and source and learned_at and updated_at):
+            continue
+        if candidate_section != section:
+            continue
+        if confirmation_state not in ("confirmed", "pending_confirmation", "inferred"):
+            continue
+
+        entry: dict[str, Any] = {
+            "field": field,
+            "value": value,
+            "source": source,
+            "learned_at": learned_at,
+            "updated_at": updated_at,
+            "section": section,
+            "confirmation_state": confirmation_state,
+        }
+
+        if section == "style" and confirmation_state == "inferred":
+            decay_raw = item.get("decay_metadata")
+            decay = decay_raw if isinstance(decay_raw, dict) else {}
+            try:
+                score = float(decay.get("decay_score", 0.0))
+            except (TypeError, ValueError):
+                score = 0.0
+            entry["decay_metadata"] = {
+                "decay_score": max(0.0, min(1.0, score)),
+                "last_seen_at": str(decay.get("last_seen_at", updated_at)).strip() or updated_at,
+                "decay_reason": str(decay.get("decay_reason", "inferred_signal")).strip() or "inferred_signal",
+            }
+
+        entries.append(entry)
+        if len(entries) >= _PROFILE_GOVERNED_MAX:
+            break
+    return entries
+
+
 def _write_project_settings_preset(project_dir: str, preset: str) -> None:
     """Persist preset metadata into project settings when settings.json exists."""
     settings_path = os.path.join(project_dir, "settings.json")
@@ -760,7 +1047,7 @@ def run_setup_wizard(
     report_path = write_adoption_report(project_dir, adoption)
     adoption["report_path"] = report_path
 
-    return {
+    result: dict[str, Any] = {
         "status": "complete",
         "setup_mode": {
             "choices": get_mode_choices(),
@@ -773,3 +1060,48 @@ def run_setup_wizard(
         "preferences": prefs,
         "adoption": adoption,
     }
+
+    # --- Post-install validation (runs AFTER all setup writes are complete) ---
+    try:
+        validation_result = _run_post_install_validate(root_dir=Path(_PROJECT_ROOT))
+    except Exception as exc:
+        validation_result = {
+            "schema": "ValidateResult",
+            "status": "fail",
+            "checks": [
+                {
+                    "name": "validation_error",
+                    "status": "blocker",
+                    "message": str(exc),
+                    "required": True,
+                },
+            ],
+            "version": "",
+        }
+
+    # Persist machine-readable validation artifact
+    artifact_dir = os.path.join(project_dir, ".omg", "state")
+    os.makedirs(artifact_dir, exist_ok=True)
+    artifact_path = os.path.join(artifact_dir, "post-install-validation.json")
+    try:
+        with open(artifact_path, "w", encoding="utf-8") as f:
+            json.dump(validation_result, f, indent=2, ensure_ascii=True)
+            f.write("\n")
+    except OSError:
+        artifact_path = ""
+
+    blockers = [
+        c for c in validation_result.get("checks", [])
+        if c.get("status") == "blocker"
+    ]
+
+    result["post_install_validation"] = {
+        "status": validation_result.get("status", "fail"),
+        "artifact_path": artifact_path,
+        "blockers": [{"name": c["name"], "message": c["message"]} for c in blockers],
+    }
+
+    if blockers:
+        result["status"] = "validation_failed"
+
+    return result

package/build/lib/plugins/advanced/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "omg-advanced",
-  "version": "2.1.0",
+  "version": "2.1.4",
   "description": "Advanced OMG commands - deep planning, learning, code review, and specialized workflows",
   "type": "omg-plugin",
   "commands": {
@@ -53,35 +53,52 @@
   "categories": {
     "planning": {
       "description": "Strategic planning and architecture",
-      "commands": ["deep-plan"]
+      "commands": [
+        "deep-plan"
+      ]
     },
     "quality": {
       "description": "Code quality and review",
-      "commands": ["code-review"]
+      "commands": [
+        "code-review"
+      ]
     },
     "knowledge": {
       "description": "Learning and skill creation",
-      "commands": ["learn"]
+      "commands": [
+        "learn"
+      ]
     },
     "delivery": {
       "description": "Shipping and release workflows",
-      "commands": ["ship"]
+      "commands": [
+        "ship"
+      ]
     },
     "collaboration": {
       "description": "Team collaboration and handoff",
-      "commands": ["handoff"]
+      "commands": [
+        "handoff"
+      ]
     },
     "automation": {
       "description": "Autonomous execution modes",
-      "commands": ["ralph-start", "ralph-stop"]
+      "commands": [
+        "ralph-start",
+        "ralph-stop"
+      ]
     },
     "thinking": {
       "description": "Structured thinking tools",
-      "commands": ["sequential-thinking"]
+      "commands": [
+        "sequential-thinking"
+      ]
     },
     "oss": {
       "description": "Open source maintainer tools",
-      "commands": ["maintainer"]
+      "commands": [
+        "maintainer"
+      ]
     }
   }
 }

package/build/lib/plugins/core/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "omg-core",
-  "version": "2.1.0",
+  "version": "2.1.4",
   "description": "Core OMG commands - native setup, routing, orchestration, and verification surfaces",
   "type": "omg-plugin",
   "commands": {
@@ -64,6 +64,11 @@
       "description": "Verify project setup and tool integration",
       "category": "setup"
     },
+    "profile-review": {
+      "path": "commands/OMG:profile-review.md",
+      "description": "Review governed profile state — preferences, confirmations, decay, provenance",
+      "category": "observability"
+    },
     "mode": {
       "path": "commands/OMG:mode.md",
       "description": "Set cognitive mode for the session",
@@ -106,43 +111,71 @@
   "categories": {
     "setup": {
       "description": "Project initialization and setup",
-      "commands": ["setup", "init", "health-check"]
+      "commands": [
+        "setup",
+        "init",
+        "health-check"
+      ]
     },
     "routing": {
       "description": "Model routing and escalation",
-      "commands": ["escalate", "teams", "ccg", "preflight"]
+      "commands": [
+        "escalate",
+        "teams",
+        "ccg",
+        "preflight"
+      ]
     },
     "verification": {
       "description": "Verification flows with normalized evidence",
-      "commands": ["browser"]
+      "commands": [
+        "browser"
+      ]
     },
     "orchestration": {
       "description": "Multi-agent orchestration modes",
-      "commands": ["crazy"]
+      "commands": [
+        "crazy"
+      ]
     },
     "compatibility": {
       "description": "Legacy compatibility",
-      "commands": ["compat"]
+      "commands": [
+        "compat"
+      ]
     },
     "config": {
       "description": "Configuration and settings",
-      "commands": ["mode"]
+      "commands": [
+        "mode"
+      ]
     },
     "observability": {
       "description": "Cost tracking and session observability",
-      "commands": ["cost", "stats", "deps"]
+      "commands": [
+        "cost",
+        "stats",
+        "deps",
+        "profile-review"
+      ]
     },
     "security": {
       "description": "Canonical security and trust checks",
-      "commands": ["security-check"]
+      "commands": [
+        "security-check"
+      ]
     },
     "contracts": {
       "description": "Contract replay and API simulation",
-      "commands": ["api-twin"]
+      "commands": [
+        "api-twin"
+      ]
     },
     "visualization": {
       "description": "Codebase visualization and architecture diagrams",
-      "commands": ["arch"]
+      "commands": [
+        "arch"
+      ]
     }
   },
   "roles": {

package/build/lib/registry/bundles/algorithms.yaml

@@ -1,6 +1,6 @@
 id: algorithms
 kind: domain-pack
-version: 2.1.0
+version: 2.1.4
 title: OMG Algorithms Pack
 description: Determinism and benchmark attachments for algorithm-heavy work.
 hosts:

package/build/lib/registry/bundles/api-twin.yaml

@@ -1,6 +1,6 @@
 id: api-twin
 kind: simulation
-version: 2.1.0
+version: 2.1.4
 title: OMG API Twin
 description: Versioned endpoint cassette replay with latency, drift, and cost reporting.
 hosts:

package/build/lib/registry/bundles/claim-judge.yaml

@@ -1,6 +1,6 @@
 id: claim-judge
 kind: proof
-version: 2.1.0
+version: 2.1.4
 title: OMG Claim Judge
 description: Evidence-backed claim validator for structured release and completion claims.
 hosts:

package/build/lib/registry/bundles/control-plane.yaml

@@ -1,6 +1,6 @@
 id: control-plane
 kind: skill
-version: 2.1.0
+version: 2.1.4
 title: OMG Control Plane
 description: Canonical production control plane bundle for Claude and Codex.
 hosts:

package/build/lib/registry/bundles/data-lineage.yaml

@@ -1,6 +1,6 @@
 id: data-lineage
 kind: provenance
-version: 2.1.0
+version: 2.1.4
 title: OMG Data Lineage
 description: Provenance and privacy tracking for traces, fixtures, examples, and synthetic artifacts.
 hosts:

package/build/lib/registry/bundles/delta-classifier.yaml

@@ -1,6 +1,6 @@
 id: delta-classifier
 kind: routing
-version: 2.1.0
+version: 2.1.4
 title: OMG Delta Classifier
 description: Change classifier that attaches risk-aware checks, approvals, and packs.
 hosts:

package/build/lib/registry/bundles/eval-gate.yaml

@@ -1,6 +1,6 @@
 id: eval-gate
 kind: evaluation
-version: 2.1.0
+version: 2.1.4
 title: OMG Eval Gate
 description: Reproducible evaluation gate that blocks regressions before release.
 hosts:

package/build/lib/registry/bundles/health.yaml

@@ -1,6 +1,6 @@
 id: health
 kind: domain-pack
-version: 2.1.0
+version: 2.1.4
 title: OMG Health Pack
 description: Health-sensitive approvals, provenance, and replay attachments.
 hosts:

package/build/lib/registry/bundles/hook-governor.yaml

@@ -1,6 +1,6 @@
 id: hook-governor
 kind: governance
-version: 2.1.0
+version: 2.1.4
 title: OMG Hook Governor
 description: Canonical hook ordering, policy reinjection, and protected-path governance.
 hosts:

package/build/lib/registry/bundles/incident-replay.yaml

@@ -1,6 +1,6 @@
 id: incident-replay
 kind: debugging
-version: 2.1.0
+version: 2.1.4
 title: OMG Incident Replay
 description: Replayable bug packs built from logs, failing tests, traces, and diffs.
 hosts:

package/build/lib/registry/bundles/lsp-pack.yaml

@@ -1,6 +1,6 @@
 id: lsp-pack
 kind: diagnostics
-version: 2.1.0
+version: 2.1.4
 title: OMG LSP Pack
 description: Optional LSP-backed diagnostics and navigation bundle for production verification.
 hosts:

package/build/lib/registry/bundles/mcp-fabric.yaml

@@ -1,6 +1,6 @@
 id: mcp-fabric
 kind: mcp
-version: 2.1.0
+version: 2.1.4
 title: OMG MCP Fabric
 description: Tools, prompts, resources, and server instructions for the OMG control plane.
 hosts:

package/build/lib/registry/bundles/plan-council.yaml

@@ -1,6 +1,6 @@
 id: plan-council
 kind: planning
-version: 2.1.0
+version: 2.1.4
 title: OMG Plan Council
 description: Canonical council-style planning bundle for explicit, evidence-backed deep plans.
 hosts:

package/build/lib/registry/bundles/preflight.yaml

@@ -1,6 +1,6 @@
 id: preflight
 kind: routing
-version: 2.1.0
+version: 2.1.4
 title: OMG Preflight
 description: Repo-aware route selection based on diff, manifests, and classified risk.
 hosts: