@trac3er/oh-my-god 2.1.4 → 2.1.7

package/runtime/session_health.py

@@ -236,3 +236,130 @@ def _to_int(value: Any, default: int) -> int:
         return int(value)
     except (TypeError, ValueError):
         return default
+
+
+_BOUNDED_ACTIONS = frozenset({"continue", "warn", "reflect", "pause", "require-review"})
+
+_HEALTH_TO_AUTO_ACTION: dict[str, str] = {
+    "block": "pause",
+    "reflect": "reflect",
+    "warn": "warn",
+    "continue": "continue",
+}
+
+
+def evaluate_auto_actions(
+    health: dict[str, Any],
+    *,
+    profile_risk: dict[str, Any] | None = None,
+    project_dir: str | None = None,
+    run_id: str = "default",
+) -> dict[str, Any]:
+    recommended = str(health.get("recommended_action", "continue"))
+    action = _HEALTH_TO_AUTO_ACTION.get(recommended, "warn")
+
+    risk = profile_risk if isinstance(profile_risk, dict) else {}
+    risk_requires_review = bool(risk.get("requires_review"))
+    has_destructive = bool(risk.get("destructive_entries"))
+
+    review_route: str | None = None
+
+    if action == "pause" and (risk_requires_review or has_destructive):
+        action = "require-review"
+        review_route = "/OMG:profile-review"
+    elif action in ("warn", "reflect") and risk_requires_review:
+        action = "require-review"
+        review_route = "/OMG:profile-review"
+    elif risk_requires_review:
+        review_route = "/OMG:profile-review"
+
+    reason = _build_action_reason(health, action, risk)
+
+    result = {
+        "action": action,
+        "reason": reason,
+        "review_route": review_route,
+        "bounded": True,
+        "health_status": str(health.get("status", "unknown")),
+        "recommended_action": recommended,
+    }
+
+    if project_dir is not None and action in ("pause", "require-review"):
+        persist_auto_action_evidence(project_dir, result, run_id=run_id)
+
+    return result
+
+
+def persist_auto_action_evidence(
+    project_dir: str,
+    action_result: dict[str, Any],
+    *,
+    run_id: str = "default",
+) -> str:
+    root = Path(project_dir)
+    actions_dir = root / ".omg" / "state" / "session_health" / "actions"
+    actions_dir.mkdir(parents=True, exist_ok=True)
+    path = actions_dir / f"{run_id}.json"
+
+    evidence: dict[str, Any] = {
+        "schema": "SessionHealthAutoAction",
+        "schema_version": "1.0.0",
+        "run_id": run_id,
+        "action": str(action_result.get("action", "continue")),
+        "reason": str(action_result.get("reason", "")),
+        "review_route": action_result.get("review_route"),
+        "bounded": True,
+        "health_status": str(action_result.get("health_status", "unknown")),
+        "recommended_action": str(action_result.get("recommended_action", "continue")),
+        "timestamp": datetime.now(timezone.utc).isoformat(),
+    }
+
+    _write_atomic(path, evidence)
+    return str(path)
+
+
+def _build_action_reason(
+    health: dict[str, Any],
+    action: str,
+    risk: dict[str, Any],
+) -> str:
+    parts: list[str] = []
+
+    contamination = _to_float(health.get("contamination_risk"), 0.0)
+    overthinking = _to_float(health.get("overthinking_score"), 0.0)
+    context_health = _to_float(health.get("context_health"), 1.0)
+
+    if action == "pause":
+        if contamination >= _DEFAULT_THRESHOLDS["contamination_risk"]["block"]:
+            parts.append(f"contamination_risk={contamination:.2f} >= block threshold")
+        if overthinking >= _DEFAULT_THRESHOLDS["overthinking_score"]["block"]:
+            parts.append(f"overthinking_score={overthinking:.2f} >= block threshold")
+    elif action == "reflect":
+        if contamination > _DEFAULT_THRESHOLDS["contamination_risk"]["reflect"]:
+            parts.append(f"contamination_risk={contamination:.2f} > reflect threshold")
+        if overthinking > _DEFAULT_THRESHOLDS["overthinking_score"]["reflect"]:
+            parts.append(f"overthinking_score={overthinking:.2f} > reflect threshold")
+    elif action == "warn":
+        verification = str(health.get("verification_status", ""))
+        if verification in ("error", "blocked"):
+            parts.append(f"verification_status={verification}")
+        if context_health <= _DEFAULT_THRESHOLDS["context_health"]["warn"]:
+            parts.append(f"context_health={context_health:.2f} <= warn threshold")
+
+    if action == "require-review":
+        if contamination >= _DEFAULT_THRESHOLDS["contamination_risk"]["block"]:
+            parts.append(f"contamination_risk={contamination:.2f} >= block threshold")
+        if overthinking >= _DEFAULT_THRESHOLDS["overthinking_score"]["block"]:
+            parts.append(f"overthinking_score={overthinking:.2f} >= block threshold")
+        destructive_count = len(risk.get("destructive_entries") or [])
+        if destructive_count:
+            parts.append(f"{destructive_count} destructive preference(s) detected")
+        parts.append("profile_risk requires review")
+
+    elif risk.get("destructive_entries"):
+        parts.append(f"{len(risk['destructive_entries'])} destructive preference(s) detected")
+
+    if not parts:
+        parts.append("session healthy")
+
+    return "; ".join(parts)

package/runtime/subagent_dispatcher.py

@@ -84,6 +84,27 @@ def _jobs_dir() -> str:
     return os.path.join(_get_project_dir(), ".omg", "state", "jobs")
 
 
+def resolve_execution_boundary(*, isolation: str = "worktree") -> dict[str, Any]:
+    normalized = isolation.strip().lower() if isolation else "none"
+    if normalized == "worktree":
+        return {
+            "sandbox_mode": "ephemeral_worktree",
+            "worker_policy": os.environ.get("OMG_WORKER_POLICY", "managed-local"),
+            "execution_mode": "local_supervisor",
+        }
+    if normalized == "container":
+        return {
+            "sandbox_mode": "container-like",
+            "worker_policy": os.environ.get("OMG_WORKER_POLICY", "managed-local"),
+            "execution_mode": "automation",
+        }
+    return {
+        "sandbox_mode": "none",
+        "worker_policy": "local-only",
+        "execution_mode": "automation",
+    }
+
+
 def _job_path(job_id: str) -> str:
     """Return the file path for a specific job."""
     return os.path.join(_jobs_dir(), f"{job_id}.json")

package/runtime/test_intent_lock.py

@@ -142,7 +142,7 @@ def verify_lock(project_dir: str, run_id: str | None, lock_id: str | None = None
     }
 
 
-def evaluate_test_delta(delta: dict[str, Any]) -> dict[str, Any]:
+def evaluate_test_delta(delta: dict[str, Any], project_dir: str | None = None) -> dict[str, Any]:
     override = delta.get("override")
     waiver_artifact = delta.get("waiver_artifact")
     if _has_override(override):
@@ -160,7 +160,10 @@ def evaluate_test_delta(delta: dict[str, Any]) -> dict[str, Any]:
     lock_payload: dict[str, Any] | None = None
     lock_id = str(delta.get("lock_id", "")).strip()
     if lock_id:
-        lock_payload = _load_lock_payload(lock_id)
+        if project_dir:
+            lock_payload = _load_lock_payload_from_project(project_dir, lock_id)
+        else:
+            lock_payload = _load_lock_payload(lock_id)
         if lock_payload is None:
             return {
                 "verdict": "fail",
@@ -175,6 +178,7 @@ def evaluate_test_delta(delta: dict[str, Any]) -> dict[str, Any]:
             old_tests=old_tests,
             new_tests=new_tests,
             touched_paths=touched_paths,
+            project_dir=project_dir,
         )
         if contract_reasons and not _has_waiver_artifact(waiver_artifact):
             unique_flags = list(dict.fromkeys(contract_flags))
@@ -352,6 +356,7 @@ def _evaluate_locked_contract(
     old_tests: list[dict[str, Any]],
     new_tests: list[dict[str, Any]],
     touched_paths: list[str],
+    project_dir: str | None = None,
 ) -> tuple[list[str], list[str]]:
     reasons: list[str] = []
     flags: list[str] = []
@@ -375,7 +380,8 @@ def _evaluate_locked_contract(
             path_key = str(selector_path).strip()
             if not path_key:
                 continue
-            current_hash = _hash_test_file(Path("."), path_key)
+            hash_project_dir = Path(project_dir) if project_dir else Path(".")
+            current_hash = _hash_test_file(hash_project_dir, path_key)
             expected_hash_value = str(expected_hash).strip() if expected_hash is not None else None
             if expected_hash_value and current_hash is None:
                 flags.append("locked_test_file_missing")

package/runtime/tool_plan_gate.py

@@ -9,6 +9,8 @@ from uuid import uuid4
 import json
 
 from runtime.context_engine import ContextEngine
+from runtime.compliance_governor import evaluate_tool_compliance
+from runtime.complexity_scorer import score_complexity
 from runtime.release_run_coordinator import resolve_current_run_id as resolve_coordinator_run_id
 from runtime.runtime_contracts import read_run_state
 
@@ -20,20 +22,6 @@ _TOOL_KEYWORDS: dict[str, tuple[str, ...]] = {
     "omg-control": ("policy", "governance", "release", "proof", "control plane"),
 }
 
-_READ_ONLY_TOOL_HINTS = (
-    "read",
-    "search",
-    "review",
-    "grep",
-    "glob",
-    "list",
-    "ls",
-    "context7",
-    "websearch",
-)
-_MUTATION_TOOLS = frozenset({"write", "edit", "multiedit", "bash"})
-
-
 def build_tool_plan(
     goal: str,
     available_tools: list[str],
@@ -73,6 +61,13 @@ def build_tool_plan(
 
     selected_tools = _apply_context_optimization(selected_tools, bounded_context, council)
     plan_id = _new_plan_id(run_id=canonical_run_id)
+    _governance: dict[str, object] = {}
+    try:
+        governance_raw = score_complexity(normalized_goal).get("governance")
+        if isinstance(governance_raw, Mapping):
+            _governance = {str(key): value for key, value in governance_raw.items()}
+    except Exception:
+        pass
     payload: dict[str, object] = {
         "plan_id": plan_id,
         "goal": normalized_goal,
@@ -83,6 +78,7 @@ def build_tool_plan(
             "goal_complexity": _goal_complexity(normalized_goal),
         },
         "context_packet": bounded_context,
+        "governance_payload": _governance,
         "council_verdicts": council.get("verdicts", {}),
         "run_id": canonical_run_id,
         "created_at": datetime.now(timezone.utc).isoformat(),
@@ -116,43 +112,21 @@ def tool_plan_gate_check(project_dir: str, run_id: str | None, tool: str) -> dic
         fallback_context=None,
     )
     clarification = _clarification_status(context_packet)
-    if clarification["requires_clarification"]:
-        reason = _clarification_reason(str(clarification["clarification_prompt"]))
-        if _is_mutation_capable_tool(tool):
-            _persist_gate_error(project_dir, run_id, tool, reason)
-            return {
-                "status": "blocked",
-                "reason": reason,
-                "run_id": run_id,
-                "tool": tool,
-                "clarification_status": clarification,
-            }
-        if _is_read_search_review_tool(tool):
-            return {
-                "status": "allowed",
-                "reason": "clarification pending; read/search/review tool allowed",
-                "run_id": run_id,
-                "clarification_status": clarification,
-            }
-
-    if has_tool_plan_for_run(project_dir, run_id):
-        council = _read_council_verdicts(project_dir, run_id)
-        verdict = _council_gate_verdict(council)
-        if verdict["blocked"]:
-            reason = str(verdict["reason"])
-            _persist_gate_error(project_dir, run_id, tool, reason)
-            return {
-                "status": "blocked",
-                "reason": reason,
-                "run_id": run_id,
-                "tool": tool,
-                "council_verdicts": council.get("verdicts", {}),
-            }
-        return {"status": "allowed", "reason": "tool plan present", "run_id": run_id}
-
-    reason = "tool plan required before mutation-capable MCP evaluation"
-    _persist_gate_error(project_dir, run_id, tool, reason)
-    return {"status": "blocked", "reason": reason, "run_id": run_id, "tool": tool}
+    decision = evaluate_tool_compliance(
+        project_dir=project_dir,
+        run_id=run_id,
+        tool=tool,
+        has_tool_plan=has_tool_plan_for_run(project_dir, run_id),
+        clarification_status=clarification,
+    )
+    reason = str(decision.get("reason", ""))
+    if decision.get("status") == "blocked":
+        _persist_gate_error(project_dir, run_id, tool, reason)
+    return {
+        **decision,
+        "run_id": run_id,
+        "tool": tool,
+    }
 
 
 def _normalize_tools(available_tools: list[str]) -> list[str]:
@@ -204,12 +178,10 @@ def _estimate_context_chars(context_packet: dict[str, object] | None) -> int:
 
 
 def _goal_complexity(goal: str) -> str:
-    length = len(goal.split())
-    if length >= 25:
-        return "high"
-    if length >= 10:
-        return "medium"
-    return "low"
+    category = str(score_complexity(goal).get("category", "low"))
+    if category == "trivial":
+        return "low"
+    return category
 
 
 def _new_plan_id(run_id: str | None) -> str:
@@ -310,23 +282,6 @@ def _read_council_verdicts(project_dir: str, run_id: str | None) -> dict[str, ob
     return {}
 
 
-def _council_gate_verdict(council: dict[str, object]) -> dict[str, object]:
-    verdicts = council.get("verdicts")
-    if not isinstance(verdicts, dict):
-        return {"blocked": False, "reason": ""}
-
-    for critic_name, critic_payload in verdicts.items():
-        if not isinstance(critic_payload, dict):
-            continue
-        token = str(critic_payload.get("verdict", "")).strip().lower()
-        if token == "fail":
-            return {
-                "blocked": True,
-                "reason": f"council critic '{critic_name}' failed; block mutation-capable tool execution",
-            }
-    return {"blocked": False, "reason": ""}
-
-
 def _apply_context_optimization(
     tools: list[dict[str, object]],
     context_packet: dict[str, object],
@@ -379,24 +334,3 @@ def _clarification_status(context_packet: dict[str, object]) -> dict[str, object
         "clarification_prompt": prompt,
         "confidence": round(max(0.0, min(1.0, confidence)), 2),
     }
-
-
-def _clarification_reason(clarification_prompt: str) -> str:
-    prompt = " ".join(str(clarification_prompt or "").split())
-    if prompt:
-        return f"Clarification required before mutation: {prompt}"
-    return "Clarification required before mutation: provide the missing intent details."
-
-
-def _is_mutation_capable_tool(tool: str) -> bool:
-    token = str(tool or "").strip().lower()
-    if token in _MUTATION_TOOLS:
-        return True
-    return token.startswith("bash:")
-
-
-def _is_read_search_review_tool(tool: str) -> bool:
-    token = str(tool or "").strip().lower()
-    if not token:
-        return False
-    return any(hint in token for hint in _READ_ONLY_TOOL_HINTS)

package/runtime/untrusted_content.py

@@ -164,6 +164,31 @@ def write_trust_evidence(inputs: list[dict[str, Any]], output_dir: str | Path) -
     return evidence_path.as_posix()
 
 
+def write_sandbox_budget_evidence(
+    *,
+    project_dir: str | Path,
+    run_id: str,
+    budget: dict[str, Any],
+    isolation: dict[str, Any],
+) -> str:
+    tagged = tag_content(
+        {
+            "source_type": "workspace",
+            "source_ref": f"forge:{run_id}",
+            "content": {
+                "run_id": run_id,
+                "budget": budget,
+                "isolation": isolation,
+            },
+        },
+        TrustTier.BALANCED,
+    )
+    return write_trust_evidence(
+        [tagged],
+        output_dir=Path(project_dir) / EVIDENCE_REL_DIR,
+    )
+
+
 def mark_untrusted_content(
     project_dir: str,
     *,

package/runtime/validate.py

@@ -15,7 +15,7 @@ from runtime.adoption import CANONICAL_VERSION
 from runtime.compat import run_doctor, _doctor_check
 from runtime.contract_compiler import validate_contract_registry
 from runtime.plugin_diagnostics import run_plugin_diagnostics
-from runtime.profile_io import load_profile, ensure_governed_preferences
+from runtime.profile_io import load_profile, ensure_governed_preferences, assess_profile_risk
 
 
 def _check_contract_registry(root_dir: Path) -> dict[str, Any]:
@@ -81,9 +81,13 @@ def _check_profile_governor(root_dir: Path) -> dict[str, Any]:
         if isinstance(e, dict) and e.get("confirmation_state") == "pending_confirmation"
     )
 
+    risk = assess_profile_risk(profile)
+    risk_level = str(risk.get("risk_level", "low"))
+
     parts = [f"{len(style_entries)} style, {len(safety_entries)} safety"]
     if pending:
         parts.append(f"{pending} pending confirmation")
+    parts.append(f"risk={risk_level}")
 
     return _doctor_check(
         "profile_governor",

package/scripts/omg.py

@@ -21,7 +21,7 @@ import json
 import os
 from pathlib import Path
 import sys
-from typing import Any
+from typing import Any, cast
 
 # --- Path resolution (never relies on CWD) ---
 SCRIPTS_DIR = os.path.dirname(os.path.abspath(__file__))
@@ -34,6 +34,8 @@ from hooks.shadow_manager import create_evidence_pack
 from hooks.trust_review import review_config_change, write_trust_manifest
 from lab.pipeline import publish_artifact, run_pipeline, run_pipeline_with_evidence
 from runtime.forge_agents import dispatch_specialists, resolve_specialists
+from runtime.forge_contracts import load_forge_mvp, validate_forge_job
+from runtime.forge_run_id import normalize_run_id
 from runtime.dispatcher import dispatch_runtime
 from runtime.api_twin import ingest_contract, record_fixture, serve_fixture, verify_fixture
 from runtime.data_lineage import build_lineage_manifest
@@ -68,10 +70,6 @@ from runtime.team_router import TeamDispatchRequest, dispatch_team, execute_ccg_
 from runtime.release_run_coordinator import resolve_current_run_id
 
 
-def _now_run_id() -> str:
-    return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
-
-
 def _parse_simple_idea_yaml(path: str) -> dict[str, Any]:
     """Minimal parser for `.omg/idea.yml` template shape."""
     idea: dict[str, Any] = {
@@ -128,6 +126,10 @@ def _ensure_project_dir() -> str:
     return os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
 
 
+def _now_run_id() -> str:
+    return datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S%fZ")
+
+
 def cmd_ship(args: argparse.Namespace) -> int:
     project_dir = _ensure_project_dir()
     idea_path = args.idea
@@ -471,12 +473,17 @@ def cmd_forge_run(args: argparse.Namespace) -> int:
         return 2
 
     project_dir = _ensure_project_dir()
-    run_id = args.run_id or _now_run_id()
+    run_id = normalize_run_id(args.run_id if args.run_id else None)
     job = json.loads(args.job_json) if args.job_json else _load_json(args.job)
 
+    valid, validation_reason = validate_forge_job(job)
+    if not valid:
+        print(json.dumps({"status": "error", "message": validation_reason}, indent=2))
+        return 2
+
     specialist_dispatch: dict[str, Any] | None = None
     if "specialists" in job or "domain" in job:
-        specialist_dispatch = dispatch_specialists(job, project_dir)
+        specialist_dispatch = dispatch_specialists(job, project_dir, run_id=run_id)
         if specialist_dispatch.get("status") == "blocked":
             print(json.dumps(specialist_dispatch, indent=2))
             return 2
@@ -501,7 +508,7 @@ def cmd_forge_vision_agent(args: argparse.Namespace) -> int:
         return 2
 
     project_dir = _ensure_project_dir()
-    run_id = args.run_id or _now_run_id()
+    run_id = normalize_run_id(args.run_id if args.run_id else None)
 
     job: dict[str, Any] = {
         "dataset": {
@@ -527,7 +534,7 @@ def cmd_forge_vision_agent(args: argparse.Namespace) -> int:
             return 2
         job.update(override)
 
-    specialist_dispatch = dispatch_specialists(job, project_dir)
+    specialist_dispatch = dispatch_specialists(job, project_dir, run_id=run_id)
     if specialist_dispatch.get("status") == "blocked":
         print(json.dumps(specialist_dispatch, indent=2))
         return 2
@@ -540,6 +547,60 @@ def cmd_forge_vision_agent(args: argparse.Namespace) -> int:
     return 0 if out.get("status") in {"ready", "failed_evaluation"} else 2
 
 
+def _cmd_forge_domain(args: argparse.Namespace, domain: str) -> int:
+    preset = args.preset
+    if preset != "labs":
+        print(
+            json.dumps(
+                {"status": "error", "message": f"forge requires labs preset, got: {preset}"},
+                indent=2,
+            )
+        )
+        return 2
+
+    project_dir = _ensure_project_dir()
+    run_id = normalize_run_id(args.run_id if args.run_id else None)
+
+    mvp = load_forge_mvp()
+    starter_templates = cast(dict[str, Any], mvp["starter_templates"])
+    job: dict[str, Any] = dict(starter_templates[domain])
+
+    if args.job_json:
+        override = json.loads(args.job_json)
+        if not isinstance(override, dict):
+            print(json.dumps({"status": "error", "message": "--job-json must be an object"}, indent=2))
+            return 2
+        job.update(override)
+
+    specialist_dispatch = dispatch_specialists(job, project_dir, run_id=run_id)
+    if specialist_dispatch.get("status") == "blocked":
+        print(json.dumps(specialist_dispatch, indent=2))
+        return 2
+
+    result = run_pipeline_with_evidence(project_dir, job, run_id)
+    out = dict(result)
+    out["specialist_dispatch"] = specialist_dispatch
+    out["agent_path"] = domain
+    print(json.dumps(out, indent=2))
+    return 0 if out.get("status") in {"ready", "failed_evaluation"} else 2
+
+
+def cmd_forge_robotics(args: argparse.Namespace) -> int:
+    return _cmd_forge_domain(args, "robotics")
+
+
+def cmd_forge_algorithms(args: argparse.Namespace) -> int:
+    return _cmd_forge_domain(args, "algorithms")
+
+
+def cmd_forge_health(args: argparse.Namespace) -> int:
+    return _cmd_forge_domain(args, "health")
+
+
+def cmd_forge_cybersecurity(args: argparse.Namespace) -> int:
+    return _cmd_forge_domain(args, "cybersecurity")
+
+
 def cmd_teams(args: argparse.Namespace) -> int:
     files = [f.strip() for f in args.files.split(",") if f.strip()] if args.files else []
     req = TeamDispatchRequest(
@@ -856,7 +917,7 @@ def _add_contract_subcommands(parent: argparse.ArgumentParser, *, dest: str) ->
 
 def cmd_profile_review(args: argparse.Namespace) -> int:
     """Read-only review of governed profile state."""
-    from runtime.profile_io import load_profile, ensure_governed_preferences, profile_version_from_map
+    from runtime.profile_io import load_profile, ensure_governed_preferences, profile_version_from_map, assess_profile_risk
 
     project_dir = _ensure_project_dir()
     profile_path = os.path.join(project_dir, ".omg", "state", "profile.yaml")
@@ -918,6 +979,8 @@ def cmd_profile_review(args: argparse.Namespace) -> int:
 
     version = profile_version_from_map(profile) if profile else ""
 
+    risk = assess_profile_risk(profile)
+
     result: dict[str, Any] = {
         "schema": "ProfileReview",
         "style": style_entries,
@@ -926,6 +989,7 @@ def cmd_profile_review(args: argparse.Namespace) -> int:
         "decay_candidates": decay_candidates,
         "provenance_summary": provenance_summary,
         "profile_version": version,
+        "risk_assessment": risk,
     }
 
     fmt = getattr(args, "format", "json")
@@ -1215,6 +1279,18 @@ def build_parser() -> argparse.ArgumentParser:
     forge_vision_agent.add_argument("--run-id", default="", help="Optional run id used for evidence output")
     forge_vision_agent.set_defaults(func=cmd_forge_vision_agent)
 
+    for _domain, _func in [
+        ("robotics", cmd_forge_robotics),
+        ("algorithms", cmd_forge_algorithms),
+        ("health", cmd_forge_health),
+        ("cybersecurity", cmd_forge_cybersecurity),
+    ]:
+        _p = forge_sub.add_parser(_domain, help=f"Run bounded {_domain} forge flow with specialist dispatch")
+        _p.add_argument("--job-json", default="", help="Optional job overrides as inline JSON")
+        _p.add_argument("--preset", default="labs", choices=list(VALID_PRESETS), help="Adoption preset (must be labs)")
+        _p.add_argument("--run-id", default="", help="Optional run id used for evidence output")
+        _p.set_defaults(func=_func)
+
     teams = sub.add_parser("teams", help="Internal OMG team routing")
     teams.add_argument("--target", default="auto", choices=["auto", "codex", "gemini", "ccg"])
     teams.add_argument("--problem", required=True)

package/scripts/print-canonical-version.py

@@ -2,7 +2,7 @@
 """Zero-dependency canonical version extractor using AST parsing.
 
 Reads CANONICAL_VERSION from runtime/adoption.py without importing it.
-Prints the semver string (e.g. "2.1.1") with trailing newline.
+Prints the semver string (e.g. "<version>") with trailing newline.
 Exit code 0 on success, non-zero on parse failure.
 """
 from __future__ import annotations
@@ -20,7 +20,7 @@ def extract_canonical_version(source_file: Path) -> str | None:
         source_file: Path to runtime/adoption.py
         
     Returns:
-        The version string (e.g. "2.1.1") or None if not found/invalid
+        The version string (e.g. "<version>") or None if not found/invalid
     """
     try:
         source_code = source_file.read_text(encoding="utf-8")