@trac3er/oh-my-god 2.1.0 → 2.1.4

package/hooks/policy_engine.py

@@ -126,6 +126,33 @@ UNTRUSTED_MUTATION_PATTERNS = [
 TRUSTED_CONTENT_TIERS = frozenset({"local", "balanced"})
 UNTRUSTED_EXTERNAL_TIERS = frozenset({"research", "browser"})
 
+INJECTION_MARKER_PATTERNS: tuple[tuple[re.Pattern[str], float, str], ...] = (
+    (re.compile(r"\bIGNORE\s+(?:ALL\s+)?PREVIOUS(?:\s+INSTRUCTIONS?)?\b", re.IGNORECASE), 0.03, "ignore-previous-instructions"),
+    (re.compile(r"<\|im_start\|>", re.IGNORECASE), 0.03, "im-start-token"),
+    (re.compile(r"<\|im_end\|>", re.IGNORECASE), 0.03, "im-end-token"),
+    (re.compile(r"\[INST\]", re.IGNORECASE), 0.03, "inst-token"),
+    (re.compile(r"\[/INST\]", re.IGNORECASE), 0.03, "inst-close-token"),
+)
+
+HIDDEN_INSTRUCTION_PATTERNS: tuple[tuple[re.Pattern[str], float, str], ...] = (
+    (re.compile(r"(?:^|\s)SYSTEM\s*:", re.IGNORECASE), 0.02, "system-role-token"),
+    (re.compile(r"(?:^|\s)ASSISTANT\s*:", re.IGNORECASE), 0.02, "assistant-role-token"),
+    (re.compile(r"(?:(?:#|//|/\*|<!--).{0,80})\b(?:ignore|override|jailbreak|bypass)\b", re.IGNORECASE), 0.01, "comment-hidden-instruction"),
+    (re.compile(r"\bbase64\s+(?:-d|--decode)\b", re.IGNORECASE), 0.01, "base64-decoder-token"),
+    (re.compile(r"\b[A-Za-z0-9+/]{48,}={0,2}\b"), 0.01, "opaque-base64-payload"),
+)
+
+CACHE_POISONING_PATTERNS: tuple[tuple[re.Pattern[str], float, str], ...] = (
+    (re.compile(r"(?:>|>>|tee\b|cp\b|mv\b|rm\b|sed\s+-i\b).{0,120}/\.omg/state/", re.IGNORECASE), 0.04, "state-path-overwrite-attempt"),
+    (re.compile(r"(?:>|>>|tee\b|cp\b|mv\b|rm\b|sed\s+-i\b).{0,120}/\.omg/shadow/active-run", re.IGNORECASE), 0.04, "active-run-overwrite-attempt"),
+    (re.compile(r"\b(?:cache|state)\s*(?:poison|override|overwrite|tamper)\b", re.IGNORECASE), 0.02, "cache-poisoning-language"),
+)
+
+CLARIFICATION_AMBIGUITY_PATTERNS: tuple[tuple[re.Pattern[str], float, str], ...] = (
+    (re.compile(r"\b(?:without\s+asking|no\s+questions\s+asked|skip\s+clarif(?:y|ication))\b", re.IGNORECASE), 0.08, "clarification-bypass-language"),
+    (re.compile(r"\b(?:just\s+fix\s+it|fix\s+everything|do\s+whatever\s+it\s+takes)\b", re.IGNORECASE), 0.08, "ambiguous-mutation-intent"),
+)
+
 
 def _project_dir() -> str:
     return os.environ.get("CLAUDE_PROJECT_DIR", os.getcwd())
@@ -211,6 +238,56 @@ def _is_untrusted_content_mode_active() -> bool:
         return False
 
 
+def scan_mutation_command(cmd: str) -> dict[str, Any]:
+    text = str(cmd or "")
+    if not text.strip():
+        return {
+            "injection_hits": 0,
+            "contamination_score": 0.0,
+            "overthinking_score": 0.0,
+            "premature_fixer_score": 0.0,
+            "signals": [],
+        }
+
+    contamination_score = 0.0
+    overthinking_score = 0.0
+    premature_fixer_score = 0.0
+    injection_hits = 0
+    signals: list[str] = []
+
+    for pattern, weight, label in INJECTION_MARKER_PATTERNS:
+        if pattern.search(text):
+            injection_hits += 1
+            contamination_score += weight
+            signals.append(label)
+
+    for pattern, weight, label in HIDDEN_INSTRUCTION_PATTERNS:
+        if pattern.search(text):
+            injection_hits += 1
+            contamination_score += weight
+            signals.append(label)
+
+    for pattern, weight, label in CACHE_POISONING_PATTERNS:
+        if pattern.search(text):
+            injection_hits += 1
+            contamination_score += weight
+            signals.append(label)
+
+    for pattern, weight, label in CLARIFICATION_AMBIGUITY_PATTERNS:
+        if pattern.search(text):
+            overthinking_score += weight
+            premature_fixer_score += weight
+            signals.append(label)
+
+    return {
+        "injection_hits": max(0, injection_hits),
+        "contamination_score": round(max(0.0, min(1.0, contamination_score)), 4),
+        "overthinking_score": round(max(0.0, min(1.0, overthinking_score)), 4),
+        "premature_fixer_score": round(max(0.0, min(1.0, premature_fixer_score)), 4),
+        "signals": signals,
+    }
+
+
 def evaluate_bash_command(cmd: str) -> PolicyDecision:
     if not cmd:
         return allow("empty command")

package/hooks/prompt-enhancer.py

@@ -14,7 +14,9 @@ Inspired by earlier OMG routing experiments. Key upgrades:
 
 No dependency on CLAUDE.md or AGENTS.md.
 """
+import hashlib
 import json, sys, os, re, time
+from datetime import datetime, timezone
 import importlib
 
 HOOKS_DIR = os.path.dirname(__file__)
@@ -77,6 +79,48 @@ def signal_matches_text(signal, text):
         return signal in text
     return re.search(r'\b' + re.escape(signal) + r'\b', text, re.IGNORECASE) is not None
 
+
+def _hash_prompt(value):
+    return hashlib.sha256(value.encode("utf-8")).hexdigest()
+
+
+def _single_line(text, max_chars=220):
+    line = " ".join(str(text).replace("\r", " ").replace("\n", " ").split())
+    if len(line) > max_chars:
+        return line[: max_chars - 3] + "..."
+    return line
+
+
+def _resolve_run_id(payload, prompt_hash):
+    if isinstance(payload, dict):
+        run_id = payload.get("run_id")
+        if isinstance(run_id, str) and run_id.strip():
+            return run_id.strip()
+        tool_input = payload.get("tool_input")
+        if isinstance(tool_input, dict):
+            metadata = tool_input.get("metadata")
+            if isinstance(metadata, dict):
+                metadata_run_id = metadata.get("run_id")
+                if isinstance(metadata_run_id, str) and metadata_run_id.strip():
+                    return metadata_run_id.strip()
+    env_run_id = os.environ.get("OMG_RUN_ID", "").strip()
+    if env_run_id:
+        return env_run_id
+    return prompt_hash[:24]
+
+
+def _count_signals(signals, text):
+    return sum(1 for sig in signals if signal_matches_text(sig, text))
+
+
+def _write_intent_gate_artifact(state_root, run_id, artifact):
+    state_path = os.path.join(state_root, "intent_gate", f"{run_id}.json")
+    os.makedirs(os.path.dirname(state_path), exist_ok=True)
+    tmp_path = f"{state_path}.tmp"
+    with open(tmp_path, "w", encoding="utf-8") as tmp_file:
+        json.dump(artifact, tmp_file, indent=2, ensure_ascii=True)
+    os.replace(tmp_path, state_path)
+
 # ── Zero-injection optimization ──
 # Simple prompts (≤10 words, no coding/mode/routing signals) get zero overhead
 _word_count_early = len(prompt_lower.split())
@@ -88,6 +132,8 @@ _has_any_signal = any([
                                                      "codex","gemini","ccg","screenshot","screen",
                                                      "security","warning","hook error","resume","handoff",
                                                      "continue","domain","scaffold","debug","deploy",
+                                                     "setup","credential","credentials","preference",
+                                                     "preferences","remember","settings","memory",
                                                      "수정","구현","버그","에러","고쳐","스크린샷","보안"]),
     _word_count_early > 10,
 ])
@@ -127,14 +173,109 @@ INTENT_MAP = {
                      "구현", "빌드", "생성", "만들", "추가", "기능", "개발"],
         "directive": "IMPLEMENT — Plan → code → test → verify. Follow existing patterns"
     },
+    "auth_setup": {
+        "signals": ["auth", "login", "credential", "credentials", "oauth", "token", "setup auth",
+                     "setup credential", "set up credential", "인증", "로그인", "자격 증명", "토큰"],
+        "directive": "AUTH_SETUP — Clarify auth target and credential source before changes"
+    },
+    "preference_memory": {
+        "signals": ["remember my settings", "remember settings", "preference", "preferences", "settings",
+                     "memory style", "save my setup", "기억", "설정", "선호"],
+        "directive": "PREFERENCE_MEMORY — Clarify scope and persistence policy before changes"
+    },
+    "ambiguous_config": {
+        "signals": ["setup", "configure", "config", "remember", "save", "setup my", "set up",
+                     "설정해", "구성", "저장"],
+        "directive": "AMBIGUOUS_CONFIG — Ask one-line clarification before any implementation"
+    },
 }
 
+IMPLEMENTATION_ACTION_SIGNALS = [
+    "implement", "build", "create", "add", "fix", "refactor", "update", "write", "code",
+    "debug", "test", "migrate", "deploy", "patch", "change", "구현", "추가", "수정", "개발",
+]
+AUTH_PROVIDER_SIGNALS = [
+    "codex", "claude", "gemini", "github", "google", "openai", "provider", "service", "cli",
+]
+AUTH_SOURCE_SIGNALS = [
+    "env", "token", "key", "secret", "credential", "password", "vault", "profile", "yaml",
+]
+PREFERENCE_SCOPE_SIGNALS = ["session", "project", "global", "default", "always", "workspace", "local"]
+
+
+def _build_intent_gate_state(prompt_text, payload):
+    has_auth = _count_signals(INTENT_MAP["auth_setup"]["signals"], prompt_text) > 0
+    has_pref = _count_signals(INTENT_MAP["preference_memory"]["signals"], prompt_text) > 0
+    has_ambiguous_config = _count_signals(INTENT_MAP["ambiguous_config"]["signals"], prompt_text) > 0
+    if not (has_auth or has_pref or has_ambiguous_config):
+        return None
+
+    has_specific_action = any(signal_matches_text(sig, prompt_text) for sig in IMPLEMENTATION_ACTION_SIGNALS)
+
+    if has_auth and has_pref:
+        intent_class = "ambiguous_config"
+    elif has_auth and has_ambiguous_config and not has_specific_action:
+        intent_class = "ambiguous_config"
+    elif has_auth:
+        intent_class = "auth_setup"
+    elif has_pref:
+        intent_class = "preference_memory"
+    else:
+        intent_class = "ambiguous_config"
+
+    missing_slots = []
+    if intent_class in ("auth_setup", "ambiguous_config"):
+        if not any(signal_matches_text(sig, prompt_text) for sig in AUTH_PROVIDER_SIGNALS):
+            missing_slots.append("provider")
+        if not any(signal_matches_text(sig, prompt_text) for sig in AUTH_SOURCE_SIGNALS):
+            missing_slots.append("credential_source")
+    if intent_class in ("preference_memory", "ambiguous_config"):
+        if not any(signal_matches_text(sig, prompt_text) for sig in PREFERENCE_SCOPE_SIGNALS):
+            missing_slots.append("scope")
+    if not has_specific_action:
+        missing_slots.append("desired_action")
+
+    requires_clarification = intent_class == "ambiguous_config" or bool(missing_slots)
+    clarification_prompt = ""
+    if requires_clarification:
+        prompt_map = {
+            "auth_setup": "Clarify auth setup in one line: target service, credential source, and exact action to run.",
+            "preference_memory": "Clarify preference memory in one line: settings to save, scope, and when to apply them.",
+            "ambiguous_config": "Clarify in one line whether this is auth setup or preference memory, plus the exact action to execute.",
+        }
+        clarification_prompt = _single_line(prompt_map[intent_class])
+
+    source_prompt_hash = _hash_prompt(prompt_text)
+    run_id = _resolve_run_id(payload, source_prompt_hash)
+    signal_hits = _count_signals(INTENT_MAP[intent_class]["signals"], prompt_text)
+    confidence = min(0.99, 0.76 + (signal_hits * 0.07) + (0.06 if intent_class == "ambiguous_config" else 0.0))
+
+    return {
+        "schema": "IntentGateClarificationState",
+        "schema_version": "1.0.0",
+        "run_id": run_id,
+        "intent_class": intent_class,
+        "confidence": round(confidence, 2),
+        "requires_clarification": requires_clarification,
+        "missing_slots": missing_slots,
+        "clarification_prompt": clarification_prompt,
+        "source_prompt_hash": source_prompt_hash,
+        "updated_at": datetime.now(timezone.utc).isoformat(),
+    }
+
 detected_intent = None
 for intent_key, intent_data in INTENT_MAP.items():
     if any(signal_matches_text(sig, prompt) for sig in intent_data["signals"]):
         detected_intent = intent_key
         break
 
+intent_gate_state = _build_intent_gate_state(prompt, data)
+if intent_gate_state is not None:
+    try:
+        _write_intent_gate_artifact(state_dir, intent_gate_state["run_id"], intent_gate_state)
+    except Exception:
+        pass
+
 # ═══════════════════════════════════════════════════════════
 # 2. DISCIPLINE SYSTEM (Sisyphus-grade)
 # ═══════════════════════════════════════════════════════════
@@ -143,6 +284,11 @@ parts = []
 if detected_intent:
     parts.append(f"@intent: {INTENT_MAP[detected_intent]['directive']}")
 
+if intent_gate_state and intent_gate_state.get("requires_clarification"):
+    clarification_line = _single_line(intent_gate_state.get("clarification_prompt", ""))
+    if clarification_line:
+        parts.append(f"@intent-clarify: {clarification_line}")
+
 parts.append(
     "@discipline: Senior-eng mode. Clean minimal code. "
     "VERIFY changes. NEVER claim done unverified. "

package/hooks/session-end-capture.py

@@ -9,14 +9,21 @@ Features are implemented in later tasks:
 import sys
 import os
 import json
+import glob
 from datetime import datetime
 from typing import Callable, cast
 
-sys.path.insert(0, os.path.dirname(__file__))
-from _common import setup_crash_handler as _setup_crash_handler
-from _common import json_input as _json_input
-from _common import get_feature_flag as _get_feature_flag
-from _common import log_hook_error as _log_hook_error
+import yaml
+
+_HOOKS_DIR = os.path.dirname(__file__)
+_PROJECT_ROOT = os.path.dirname(_HOOKS_DIR)
+if _PROJECT_ROOT not in sys.path:
+    sys.path.insert(0, _PROJECT_ROOT)
+
+from hooks._common import setup_crash_handler as _setup_crash_handler
+from hooks._common import json_input as _json_input
+from hooks._common import get_feature_flag as _get_feature_flag
+from hooks._common import log_hook_error as _log_hook_error
 
 setup_crash_handler = cast(Callable[[str, bool], None], _setup_crash_handler)
 json_input = cast(Callable[[], dict[str, str]], _json_input)
@@ -25,6 +32,362 @@ log_hook_error = cast(Callable[[str, str], None], _log_hook_error)
 
 setup_crash_handler('session-end-capture', False)
 
+_PROFILE_ARCH_REQUEST_MAX = 8
+_PROFILE_TAG_MAX = 12
+_PROFILE_RECENT_UPDATES_MAX = 5
+_MIN_SIGNAL_CONFIDENCE = 0.7
+
+
+def _read_json_file(path: str) -> dict[str, object]:
+    if not os.path.exists(path):
+        return {}
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as file_obj:
+            payload = json.load(file_obj)
+    except (OSError, json.JSONDecodeError, ValueError):
+        return {}
+    if isinstance(payload, dict):
+        return payload
+    return {}
+
+
+def _read_recent_failure_entries(project_dir: str, limit: int = 20) -> list[dict[str, object]]:
+    ledger_dir = os.path.join(project_dir, ".omg", "state", "ledger")
+    if not os.path.exists(ledger_dir):
+        return []
+
+    entries: list[dict[str, object]] = []
+    try:
+        failure_files = sorted(glob.glob(os.path.join(ledger_dir, "failure-*.jsonl")))
+    except OSError:
+        return []
+
+    for file_path in failure_files[-5:]:
+        try:
+            with open(file_path, "r", encoding="utf-8", errors="replace") as file_obj:
+                for line in file_obj:
+                    text = line.strip()
+                    if not text:
+                        continue
+                    try:
+                        payload = json.loads(text)
+                    except (TypeError, ValueError, json.JSONDecodeError):
+                        continue
+                    if isinstance(payload, dict):
+                        entries.append(cast(dict[str, object], payload))
+        except OSError:
+            continue
+    return entries[-limit:]
+
+
+def _normalize_tag_token(value: str) -> str:
+    lowered = value.strip().lower().replace(" ", "_")
+    return "".join(ch for ch in lowered if ch.isalnum() or ch in ("_", "-"))
+
+
+def _normalize_constraint_key(value: str) -> str:
+    lowered = value.strip().lower().replace(" ", "_")
+    return "".join(ch for ch in lowered if ch.isalnum() or ch == "_")
+
+
+def _normalize_constraint_value(value: object) -> 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 = " ".join(str(value).strip().split()).lower()
+    return text if text else None
+
+
+def _ensure_profile_baseline(profile: dict[str, object]) -> None:
+    preferences_obj = profile.get("preferences")
+    preferences = preferences_obj if isinstance(preferences_obj, dict) else {}
+    arch_obj = preferences.get("architecture_requests")
+    preferences["architecture_requests"] = arch_obj if isinstance(arch_obj, list) else []
+    constraints_obj = preferences.get("constraints")
+    preferences["constraints"] = constraints_obj if isinstance(constraints_obj, dict) else {}
+    profile["preferences"] = preferences
+
+    user_vector_obj = profile.get("user_vector")
+    user_vector = user_vector_obj if isinstance(user_vector_obj, dict) else {}
+    tags_obj = user_vector.get("tags")
+    user_vector["tags"] = tags_obj if isinstance(tags_obj, list) else []
+    profile["user_vector"] = user_vector
+
+    provenance_obj = profile.get("profile_provenance")
+    provenance = provenance_obj if isinstance(provenance_obj, dict) else {}
+    updates_obj = provenance.get("recent_updates")
+    provenance["recent_updates"] = updates_obj if isinstance(updates_obj, list) else []
+    profile["profile_provenance"] = provenance
+
+    try:
+        from runtime.profile_io import ensure_governed_preferences
+        ensure_governed_preferences(cast(dict[str, object], profile))
+    except Exception:
+        profile["governed_preferences"] = {"style": [], "safety": []}
+
+
+def _record_provenance(
+    profile: dict[str, object],
+    *,
+    run_id: str,
+    source: str,
+    field: str,
+    updated_at: str,
+) -> None:
+    provenance = cast(dict[str, object], profile["profile_provenance"])
+    raw_updates = provenance.get("recent_updates", [])
+    updates = raw_updates if isinstance(raw_updates, list) else []
+    updates.append(
+        {
+            "run_id": run_id,
+            "source": source,
+            "field": field,
+            "updated_at": updated_at,
+        }
+    )
+    provenance["recent_updates"] = updates[-_PROFILE_RECENT_UPDATES_MAX:]
+
+
+def _signal_is_contradicted(
+    signal: dict[str, object],
+    council_payload: dict[str, object],
+    failure_entries: list[dict[str, object]],
+) -> bool:
+    if bool(signal.get("contradicted") is True):
+        return True
+
+    field = str(signal.get("field", "")).strip()
+    verdicts_obj = council_payload.get("verdicts")
+    verdicts = verdicts_obj if isinstance(verdicts_obj, dict) else {}
+    for verdict in verdicts.values():
+        if not isinstance(verdict, dict):
+            continue
+        notes = " ".join(
+            str(verdict.get(part, ""))
+            for part in ("reason", "notes", "message", "detail")
+        ).lower()
+        if "contradict" in notes and (not field or field in notes):
+            return True
+
+    for entry in failure_entries:
+        if bool(entry.get("contradicted") is True):
+            entry_field = str(entry.get("field", "")).strip()
+            if not entry_field or entry_field == field:
+                return True
+        detail = " ".join(
+            str(entry.get(part, ""))
+            for part in ("error", "reason", "message", "detail")
+        ).lower()
+        if "contradict" in detail and (not field or field in detail):
+            return True
+    return False
+
+
+def _promote_preference_learning(project_dir: str, run_id: str) -> None:
+    project_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    if project_root not in sys.path:
+        sys.path.insert(0, project_root)
+    try:
+        from runtime.memory_store import project_preference_signals
+    except Exception:
+        return
+
+    intent_gate_path = os.path.join(project_dir, ".omg", "state", "intent_gate", f"{run_id}.json")
+    council_path = os.path.join(project_dir, ".omg", "state", "council_verdicts", f"{run_id}.json")
+    health_path = os.path.join(project_dir, ".omg", "state", "session_health", f"{run_id}.json")
+    profile_path = os.path.join(project_dir, ".omg", "state", "profile.yaml")
+
+    intent_gate = _read_json_file(intent_gate_path)
+    council_payload = _read_json_file(council_path)
+    session_health = _read_json_file(health_path)
+    failure_entries = _read_recent_failure_entries(project_dir)
+
+    candidate_signals = project_preference_signals(project_dir, max_signals=12)
+    if not candidate_signals:
+        return
+
+    if not os.path.exists(profile_path):
+        return
+
+    try:
+        from runtime.profile_io import load_profile
+        profile = cast(dict[str, object], load_profile(profile_path))
+    except Exception:
+        return
+    if not profile:
+        return
+    had_governed = isinstance(profile.get("governed_preferences"), dict)
+    _ensure_profile_baseline(profile)
+    baseline_changed = not had_governed
+
+    health_status = str(session_health.get("status", "")).strip().lower()
+    health_action = str(session_health.get("recommended_action", "")).strip().lower()
+    council_status = str(council_payload.get("status", "")).strip().lower()
+    requires_clarification = bool(intent_gate.get("requires_clarification") is True)
+    inferred_blocked = (
+        health_status == "blocked"
+        or health_action == "block"
+        or council_status in ("blocked", "fail")
+        or requires_clarification
+    )
+
+    inferred_counts: dict[tuple[str, str], int] = {}
+    explicit_to_apply: list[dict[str, object]] = []
+    inferred_to_apply: list[dict[str, object]] = []
+
+    for signal in candidate_signals:
+        confidence = signal.get("confidence", 0.0)
+        try:
+            signal_confidence = float(confidence)
+        except (TypeError, ValueError):
+            signal_confidence = 0.0
+        if signal_confidence < _MIN_SIGNAL_CONFIDENCE:
+            continue
+        if _signal_is_contradicted(signal, council_payload, failure_entries):
+            continue
+
+        source = str(signal.get("source", "")).strip().lower()
+        if source in ("explicit_user", "direct_user", "user_stated"):
+            explicit_to_apply.append(signal)
+            continue
+
+        field = str(signal.get("field", "")).strip()
+        value = " ".join(str(signal.get("value", "")).strip().split())
+        if not field or not value:
+            continue
+        key = (field, value)
+        inferred_counts[key] = inferred_counts.get(key, 0) + 1
+        inferred_to_apply.append(signal)
+
+    pending_writes: list[dict[str, object]] = list(explicit_to_apply)
+    if not inferred_blocked:
+        for signal in inferred_to_apply:
+            field = str(signal.get("field", "")).strip()
+            value = " ".join(str(signal.get("value", "")).strip().split())
+            if inferred_counts.get((field, value), 0) >= 2:
+                pending_writes.append(signal)
+
+    if not pending_writes:
+        if baseline_changed:
+            try:
+                from runtime.profile_io import save_profile
+                save_profile(profile_path, profile)
+            except Exception:
+                pass
+        return
+
+    updated_at = datetime.utcnow().isoformat() + "Z"
+    changed = False
+    for signal in pending_writes:
+        field = str(signal.get("field", "")).strip()
+        value = " ".join(str(signal.get("value", "")).strip().split())
+        if not field or not value:
+            continue
+
+        source = str(signal.get("source", "")).strip().lower() or "inferred_observation"
+        section = str(signal.get("section", "style")).strip().lower() or "style"
+        is_destructive = bool(signal.get("destructive") is True)
+
+        if section not in ("style", "safety"):
+            section = "style"
+
+        if is_destructive:
+            confirmation_state = "pending_confirmation"
+        elif source in ("explicit_user", "direct_user", "user_stated"):
+            confirmation_state = "confirmed"
+        else:
+            confirmation_state = "inferred"
+
+        decay_metadata: dict[str, object] | None = None
+        if section == "style" and confirmation_state == "inferred":
+            decay_metadata = {
+                "decay_score": 0.0,
+                "last_seen_at": updated_at,
+                "decay_reason": "inferred_signal",
+            }
+
+        try:
+            from runtime.profile_io import upsert_governed_preference
+            upsert_governed_preference(
+                cast(dict[str, object], profile),
+                field=field,
+                value=value,
+                source=source,
+                learned_at=updated_at,
+                updated_at=updated_at,
+                section=section,
+                confirmation_state=confirmation_state,
+                decay_metadata=decay_metadata,
+            )
+            changed = True
+        except Exception:
+            pass
+
+        if confirmation_state == "pending_confirmation":
+            continue
+
+        preferences = cast(dict[str, object], profile["preferences"])
+        user_vector = cast(dict[str, object], profile["user_vector"])
+
+        if field == "preferences.architecture_requests":
+            raw_arch = preferences.get("architecture_requests", [])
+            arch = raw_arch if isinstance(raw_arch, list) else []
+            if value in arch:
+                continue
+            arch.append(value)
+            preferences["architecture_requests"] = arch[-_PROFILE_ARCH_REQUEST_MAX:]
+            _record_provenance(profile, run_id=run_id, source=source, field=field, updated_at=updated_at)
+            changed = True
+            continue
+
+        if field.startswith("preferences.constraints."):
+            constraint_key = _normalize_constraint_key(field.split("preferences.constraints.", 1)[1])
+            constraint_value = _normalize_constraint_value(value)
+            if not constraint_key or constraint_value is None:
+                continue
+            raw_constraints = preferences.get("constraints", {})
+            constraints = raw_constraints if isinstance(raw_constraints, dict) else {}
+            if constraints.get(constraint_key) == constraint_value:
+                continue
+            constraints[constraint_key] = constraint_value
+            preferences["constraints"] = constraints
+            _record_provenance(profile, run_id=run_id, source=source, field=field, updated_at=updated_at)
+            changed = True
+            continue
+
+        if field == "user_vector.tags":
+            token = _normalize_tag_token(value)
+            if not token:
+                continue
+            raw_tags = user_vector.get("tags", [])
+            tags = raw_tags if isinstance(raw_tags, list) else []
+            if token in tags:
+                continue
+            tags.append(token)
+            user_vector["tags"] = tags[-_PROFILE_TAG_MAX:]
+            _record_provenance(profile, run_id=run_id, source=source, field=field, updated_at=updated_at)
+            changed = True
+
+    if not changed:
+        if baseline_changed:
+            try:
+                from runtime.profile_io import save_profile
+                save_profile(profile_path, profile)
+            except Exception:
+                pass
+        return
+
+    try:
+        from runtime.profile_io import save_profile
+        save_profile(profile_path, profile)
+    except Exception:
+        return
+
 data = json_input()
 session_id = data.get('session_id', 'unknown')
 cwd = data.get('cwd', os.getcwd())
@@ -32,7 +395,7 @@ cwd = data.get('cwd', os.getcwd())
 # Capture A: Memory (implemented in Task 19)
 if get_feature_flag('memory'):
     try:
-        from _memory import save_memory, rotate_memories
+        from hooks._memory import save_memory, rotate_memories
 
         summary_parts = [f"# Session: {datetime.now().strftime('%Y-%m-%d')} ({session_id[:8]})"]
 
@@ -134,4 +497,9 @@ if get_feature_flag('compound_learning'):
     except Exception as e:
         log_hook_error('session-end-capture', str(e))
 
+try:
+    _promote_preference_learning(cwd, session_id)
+except Exception as e:
+    log_hook_error('session-end-capture', str(e))
+
 sys.exit(0)