nexo-brain 4.1.0 → 5.0.0

package/src/dashboard/templates/cortex.html

@@ -31,20 +31,20 @@
 <!-- Stats row -->
 <div class="grid grid-cols-4 gap-4 mb-6">
   <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
-    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Total Decisions</p>
+    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Alt Evaluations</p>
     <p class="text-2xl font-display font-bold text-slate-100" id="stat-decisions">--</p>
   </div>
   <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
-    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Avg Confidence</p>
+    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Accept Rate</p>
     <p class="text-2xl font-display font-bold text-nexo-400" id="stat-confidence">--</p>
   </div>
   <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
-    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Cortex Logs</p>
+    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Linked Outcomes</p>
     <p class="text-2xl font-display font-bold text-slate-100" id="stat-logs">--</p>
   </div>
   <div class="bg-slate-900/50 border border-slate-800/50 rounded-xl p-5 card">
-    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Success Rate</p>
-    <p class="text-2xl font-display font-bold text-emerald-400" id="stat-success">--</p>
+    <p class="text-xs uppercase tracking-wider text-slate-500 font-semibold mb-1">Override Rate</p>
+    <p class="text-2xl font-display font-bold text-amber-400" id="stat-success">--</p>
   </div>
 </div>
 
@@ -77,7 +77,7 @@
       <span class="text-[10px] text-slate-600 font-mono" id="decisions-count">--</span>
     </div>
     <div id="decisions-list" class="space-y-3 max-h-[600px] overflow-y-auto pr-1">
-      <div class="py-12 text-center text-sm text-slate-500">Loading decisions...</div>
+      <div class="py-12 text-center text-sm text-slate-500">Loading decision support...</div>
     </div>
   </div>
 </div>
@@ -94,6 +94,7 @@
 <script>
   let allLogs = [];
   let allDecisions = [];
+  let allEvaluations = [];
 
   const modeColors = {
     conservative: { bg: 'bg-blue-500/15', text: 'text-blue-400', border: 'border-blue-500/30' },
@@ -156,16 +157,69 @@
     }).join('');
   }
 
-  function renderDecisions(decisions) {
+  function renderDecisions(evaluations, decisions) {
     const container = document.getElementById('decisions-list');
-    document.getElementById('decisions-count').textContent = `${decisions.length} decisions`;
+    document.getElementById('decisions-count').textContent = `${evaluations.length} evaluations / ${decisions.length} decisions`;
 
-    if (!decisions.length) {
-      container.innerHTML = '<div class="py-12 text-center text-sm text-slate-500">No decisions recorded</div>';
+    if (!evaluations.length && !decisions.length) {
+      container.innerHTML = '<div class="py-12 text-center text-sm text-slate-500">No decision support recorded</div>';
       return;
     }
 
-    container.innerHTML = decisions.slice(0, 50).map((d, i) => `
+    const evaluationCards = evaluations.slice(0, 25).map((item, i) => {
+      const scores = Array.isArray(item.scores) ? item.scores : JSON.parse(item.scores || '[]');
+      const top = scores[0] || null;
+      const selectedChanged = item.selection_source === 'override';
+      return `
+      <div class="bg-slate-800/30 rounded-lg p-4 hover:bg-slate-800/50 transition-colors border border-transparent hover:border-slate-700/50 animate-fade-in" style="animation-delay: ${i * 35}ms">
+        <div class="flex items-center justify-between mb-2 gap-2">
+          <div class="flex items-center gap-2 flex-wrap">
+            ${item.impact_level ? `<span class="inline-flex items-center px-2 py-0.5 rounded-md text-[10px] font-semibold bg-red-500/15 text-red-300 uppercase tracking-wider">${escapeHtml(item.impact_level)}</span>` : ''}
+            ${item.area ? `<span class="inline-flex items-center px-2 py-0.5 rounded-md text-[10px] font-semibold bg-nexo-500/15 text-nexo-400 uppercase tracking-wider">${escapeHtml(item.area)}</span>` : ''}
+          </div>
+          <span class="text-[10px] text-slate-600">${relativeTime(item.created_at)}</span>
+        </div>
+        <p class="text-sm text-slate-200 mb-2">${escapeHtml(item.goal || '--')}</p>
+        <div class="grid grid-cols-2 gap-2 mb-2">
+          <div class="bg-slate-900/40 rounded-md p-2">
+            <p class="text-[10px] uppercase tracking-wider text-slate-500 mb-1">Recommended</p>
+            <p class="text-xs text-emerald-400 font-semibold">${escapeHtml(item.recommended_choice || '--')}</p>
+          </div>
+          <div class="bg-slate-900/40 rounded-md p-2">
+            <p class="text-[10px] uppercase tracking-wider text-slate-500 mb-1">Selected</p>
+            <p class="text-xs ${selectedChanged ? 'text-amber-400' : 'text-slate-200'} font-semibold">${escapeHtml(item.selected_choice || '--')}</p>
+          </div>
+        </div>
+        ${item.recommended_reasoning ? `<p class="text-xs text-slate-400 mb-2">${escapeHtml(item.recommended_reasoning)}</p>` : ''}
+        ${item.goal_profile_id ? `
+          <div class="mt-2 bg-slate-900/40 rounded px-2 py-1.5">
+            <p class="text-[10px] text-slate-500 uppercase tracking-wider font-semibold mb-0.5">Goal Profile</p>
+            <p class="text-xs text-nexo-300 font-semibold">${escapeHtml(item.goal_profile_id)}</p>
+            ${Array.isArray(item.goal_profile_labels) && item.goal_profile_labels.length ? `<p class="text-[10px] text-slate-400 mt-1">${escapeHtml(item.goal_profile_labels.join(' · '))}</p>` : ''}
+          </div>
+        ` : ''}
+        ${item.linked_outcome_id ? `
+          <div class="mt-2 text-[10px] text-slate-500">
+            outcome #${escapeHtml(String(item.linked_outcome_id))}
+            ${item.linked_outcome?.status ? `· <span class="text-slate-300">${escapeHtml(String(item.linked_outcome.status))}</span>` : ''}
+          </div>
+        ` : ''}
+        ${selectedChanged && item.selection_reason ? `
+          <div class="mt-2 bg-amber-500/10 rounded px-2 py-1.5">
+            <p class="text-[10px] text-amber-400 font-semibold uppercase tracking-wider mb-0.5">Override</p>
+            <p class="text-xs text-amber-200/90">${escapeHtml(item.selection_reason)}</p>
+          </div>
+        ` : ''}
+        ${top ? `
+          <div class="mt-2 text-[10px] text-slate-500 font-mono">
+            top=${Number(top.total_score || 0).toFixed(2)} impact=${Number(top.impact || 0).toFixed(1)} success=${Number(top.success_probability || 0).toFixed(1)} risk=${Number(top.risk_level || 0).toFixed(1)}
+          </div>
+        ` : ''}
+      </div>
+      `;
+    }).join('');
+
+    const decisionCards = decisions.slice(0, 20).map((d, i) => `
       <div class="bg-slate-800/30 rounded-lg p-4 hover:bg-slate-800/50 transition-colors border border-transparent hover:border-slate-700/50 animate-fade-in" style="animation-delay: ${i * 40}ms">
         <div class="flex items-center justify-between mb-2">
           <div class="flex items-center gap-2">
@@ -190,6 +244,15 @@
         </div>
       </div>
     `).join('');
+
+    const decisionSection = decisionCards ? `
+      <div class="pt-3 mt-3 border-t border-slate-800/80">
+        <p class="text-[10px] uppercase tracking-wider text-slate-500 font-semibold mb-3">Decision Log</p>
+        <div class="space-y-3">${decisionCards}</div>
+      </div>
+    ` : '';
+
+    container.innerHTML = evaluationCards + decisionSection;
   }
 
   function renderConfidenceChart(decisions) {
@@ -217,9 +280,10 @@
 
     const filteredLogs = modeFilter ? allLogs.filter(l => l.mode === modeFilter) : allLogs;
     const filteredDecisions = domainFilter ? allDecisions.filter(d => d.domain === domainFilter) : allDecisions;
+    const filteredEvaluations = domainFilter ? allEvaluations.filter(e => e.area === domainFilter) : allEvaluations;
 
     renderLogs(filteredLogs);
-    renderDecisions(filteredDecisions);
+    renderDecisions(filteredEvaluations, filteredDecisions);
   }
 
   async function loadData() {
@@ -228,29 +292,24 @@
 
     allLogs = data.cortex_logs || [];
     allDecisions = data.decisions || [];
+    allEvaluations = data.evaluations || [];
+    const summary = data.summary || {};
 
     // Populate domain filter
-    const domains = [...new Set(allDecisions.map(d => d.domain).filter(Boolean))];
+    const domains = [...new Set([
+      ...allDecisions.map(d => d.domain).filter(Boolean),
+      ...allEvaluations.map(e => e.area).filter(Boolean),
+    ])];
     const domainSelect = document.getElementById('filter-domain');
     const currentDomain = domainSelect.value;
     domainSelect.innerHTML = '<option value="">All Domains</option>' +
       domains.map(d => `<option value="${escapeHtml(d)}" ${d === currentDomain ? 'selected' : ''}>${escapeHtml(d)}</option>`).join('');
 
     // Stats
-    document.getElementById('stat-decisions').textContent = formatNumber(allDecisions.length);
-    document.getElementById('stat-logs').textContent = formatNumber(allLogs.length);
-
-    const confidences = allDecisions.filter(d => d.confidence != null).map(d => {
-      const v = typeof d.confidence === 'number' ? (d.confidence > 1 ? d.confidence : d.confidence * 100) : parseFloat(d.confidence);
-      return v;
-    });
-    const avgConf = confidences.length ? (confidences.reduce((a, b) => a + b, 0) / confidences.length) : 0;
-    document.getElementById('stat-confidence').textContent = avgConf.toFixed(0) + '%';
-
-    const outcomes = allDecisions.filter(d => d.outcome);
-    const successes = outcomes.filter(d => d.outcome === 'success' || d.outcome === 'positive' || d.outcome === 'good');
-    const successRate = outcomes.length ? ((successes.length / outcomes.length) * 100) : 0;
-    document.getElementById('stat-success').textContent = successRate.toFixed(0) + '%';
+    document.getElementById('stat-decisions').textContent = formatNumber(allEvaluations.length);
+    document.getElementById('stat-confidence').textContent = `${Number(summary.recommendation_accept_rate || 0).toFixed(0)}%`;
+    document.getElementById('stat-logs').textContent = formatNumber(summary.linked_outcomes_total || 0);
+    document.getElementById('stat-success').textContent = `${Number(summary.override_rate || 0).toFixed(0)}%`;
 
     renderConfidenceChart(allDecisions);
     applyFilters();

package/src/db/__init__.py

@@ -52,6 +52,8 @@ _personal_scripts = _load_submodule("db._personal_scripts")
 _skills = _load_submodule("db._skills")
 _hot_context = _load_submodule("db._hot_context")
 _drive = _load_submodule("db._drive")
+_outcomes = _load_submodule("db._outcomes")
+_goal_profiles = _load_submodule("db._goal_profiles")
 
 # Core: connection, constants, init, utils
 from db._core import (
@@ -88,6 +90,7 @@ from db._reminders import (
     create_followup, update_followup, complete_followup, delete_followup,
     restore_followup, add_followup_note, get_followups, get_followup, get_followup_history,
     find_similar_followups,
+    compute_followup_impact, score_followup, score_active_followups,
     add_item_history, get_item_history, validate_item_read_token,
 )
 
@@ -147,6 +150,10 @@ from db._protocol import (
     create_protocol_task, get_protocol_task, close_protocol_task,
     create_protocol_debt, resolve_protocol_debts, list_protocol_debts,
     protocol_compliance_summary,
+    create_cortex_evaluation, get_cortex_evaluation, list_cortex_evaluations,
+    cortex_evaluation_summary,
+    latest_cortex_evaluation_for_task, task_has_cortex_evaluation,
+    override_cortex_evaluation,
 )
 
 # Durable workflow runtime
@@ -185,6 +192,7 @@ from db._skills import (
     validate_skill_params, render_command_template, sync_skill_directories,
     import_skill_from_directory, approve_skill, collect_scriptable_skill_candidates,
     collect_skill_improvement_candidates, materialize_personal_skill_definition,
+    get_skill_outcome_evidence, list_skill_outcome_reviews,
     get_skill_health_report,
 )
 
@@ -206,6 +214,23 @@ from db._hot_context import (
     resolve_hot_context,
 )
 
+# Outcomes
+from db._outcomes import (
+    VALID_METRIC_SOURCES as OUTCOME_METRIC_SOURCES,
+    VALID_TARGET_OPERATORS as OUTCOME_TARGET_OPERATORS,
+    create_outcome, get_outcome, list_outcomes,
+    cancel_outcome, evaluate_outcome, pending_outcomes_due,
+    find_pending_outcomes_by_action, set_linked_outcomes_met,
+    list_outcome_pattern_candidates, capture_outcome_pattern,
+)
+
+# Goal Engine v1
+from db._goal_profiles import (
+    DEFAULT_GOAL_PROFILES,
+    ensure_default_goal_profiles, get_goal_profile, list_goal_profiles,
+    upsert_goal_profile, resolve_goal_profile,
+)
+
 
 def get_db():
     return _module("db._core").get_db()

package/src/db/_goal_profiles.py

@@ -0,0 +1,376 @@
+from __future__ import annotations
+"""Goal Engine v1 — explicit optimization profiles for durable goals and decisions."""
+
+import json
+
+from db._core import get_db
+from db._workflow import get_workflow_goal
+
+VALID_SCOPE_TYPES = {"default", "area", "task_type", "goal_id"}
+VALID_STATUSES = {"active", "disabled"}
+WEIGHT_KEYS = ("impact", "success", "risk", "somatic")
+DEFAULT_WEIGHTS = {
+    "impact": 0.35,
+    "success": 0.30,
+    "risk": 0.20,
+    "somatic": 0.15,
+}
+DEFAULT_GOAL_PROFILES = (
+    {
+        "profile_id": "default_balanced",
+        "profile_name": "Balanced default",
+        "description": "Balancea impacto, exito, riesgo y huella somatica para decisiones generales.",
+        "scope_type": "default",
+        "scope_value": "",
+        "goal_labels": ["maximise_success", "minimise_risk", "preserve_trust"],
+        "weights": DEFAULT_WEIGHTS,
+        "status": "active",
+        "source": "system",
+    },
+    {
+        "profile_id": "release_safety",
+        "profile_name": "Release safety",
+        "description": "Favorece decisiones reversibles y verificadas en release, deploy y cambios publicos.",
+        "scope_type": "area",
+        "scope_value": "release",
+        "goal_labels": ["minimise_risk", "preserve_trust", "maximise_success"],
+        "weights": {
+            "impact": 0.24,
+            "success": 0.28,
+            "risk": 0.30,
+            "somatic": 0.18,
+        },
+        "status": "active",
+        "source": "system",
+    },
+    {
+        "profile_id": "customer_trust",
+        "profile_name": "Customer trust",
+        "description": "Favorece decisiones que preservan confianza y reducen friccion con clientes.",
+        "scope_type": "area",
+        "scope_value": "customer",
+        "goal_labels": ["preserve_trust", "maximise_success", "minimise_risk"],
+        "weights": {
+            "impact": 0.25,
+            "success": 0.31,
+            "risk": 0.26,
+            "somatic": 0.18,
+        },
+        "status": "active",
+        "source": "system",
+    },
+    {
+        "profile_id": "ops_efficiency",
+        "profile_name": "Operations efficiency",
+        "description": "Favorece throughput operativo manteniendo riesgo contenido en ejecucion rutinaria.",
+        "scope_type": "task_type",
+        "scope_value": "execute",
+        "goal_labels": ["maximise_efficiency", "maximise_success", "minimise_risk"],
+        "weights": {
+            "impact": 0.38,
+            "success": 0.28,
+            "risk": 0.20,
+            "somatic": 0.14,
+        },
+        "status": "active",
+        "source": "system",
+    },
+    {
+        "profile_id": "business_growth",
+        "profile_name": "Business growth",
+        "description": "Da mas peso a impacto y exito cuando el contexto busca crecimiento o revenue.",
+        "scope_type": "area",
+        "scope_value": "business",
+        "goal_labels": ["maximise_business_impact", "maximise_success"],
+        "weights": {
+            "impact": 0.56,
+            "success": 0.22,
+            "risk": 0.14,
+            "somatic": 0.08,
+        },
+        "status": "active",
+        "source": "system",
+    },
+)
+
+
+def _parse_json(value, default):
+    if value in (None, ""):
+        return default
+    if isinstance(value, (dict, list)):
+        return value
+    try:
+        return json.loads(value)
+    except Exception:
+        return default
+
+
+def _normalize_goal_labels(labels) -> list[str]:
+    parsed = _parse_json(labels, labels if isinstance(labels, list) else [])
+    if not isinstance(parsed, list):
+        return []
+    seen: set[str] = set()
+    result: list[str] = []
+    for item in parsed:
+        clean = str(item or "").strip()
+        if not clean or clean in seen:
+            continue
+        seen.add(clean)
+        result.append(clean)
+    return result
+
+
+def _normalize_weights(weights) -> dict:
+    parsed = _parse_json(weights, weights if isinstance(weights, dict) else {})
+    if not isinstance(parsed, dict):
+        parsed = {}
+    collected: dict[str, float] = {}
+    for key in WEIGHT_KEYS:
+        try:
+            value = float(parsed.get(key, DEFAULT_WEIGHTS[key]))
+        except (TypeError, ValueError):
+            value = DEFAULT_WEIGHTS[key]
+        collected[key] = max(0.01, value)
+    total = sum(collected.values())
+    if total <= 0:
+        collected = dict(DEFAULT_WEIGHTS)
+        total = sum(collected.values())
+    return {key: round(collected[key] / total, 4) for key in WEIGHT_KEYS}
+
+
+def _row_to_goal_profile(row, *, resolved_by: str = "") -> dict | None:
+    if not row:
+        return None
+    profile = dict(row)
+    profile["goal_labels"] = _normalize_goal_labels(profile.get("goal_labels"))
+    profile["weights"] = _normalize_weights(profile.get("weights"))
+    if resolved_by:
+        profile["resolved_by"] = resolved_by
+    return profile
+
+
+def ensure_default_goal_profiles() -> None:
+    conn = get_db()
+    for profile in DEFAULT_GOAL_PROFILES:
+        conn.execute(
+            """INSERT OR IGNORE INTO goal_profiles (
+                   profile_id, profile_name, description, scope_type, scope_value,
+                   goal_labels, weights, status, source
+               ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                profile["profile_id"],
+                profile["profile_name"],
+                profile["description"],
+                profile["scope_type"],
+                profile["scope_value"],
+                json.dumps(profile["goal_labels"], ensure_ascii=False),
+                json.dumps(_normalize_weights(profile["weights"]), ensure_ascii=False),
+                profile["status"],
+                profile["source"],
+            ),
+        )
+    conn.commit()
+
+
+def get_goal_profile(profile_id: str) -> dict | None:
+    ensure_default_goal_profiles()
+    conn = get_db()
+    row = conn.execute(
+        "SELECT * FROM goal_profiles WHERE profile_id = ?",
+        ((profile_id or "").strip(),),
+    ).fetchone()
+    return _row_to_goal_profile(row)
+
+
+def list_goal_profiles(*, scope_type: str = "", status: str = "active", limit: int = 50) -> list[dict]:
+    ensure_default_goal_profiles()
+    conn = get_db()
+    clauses = []
+    params: list[object] = []
+    clean_scope = (scope_type or "").strip()
+    clean_status = (status or "").strip()
+    if clean_scope:
+        clauses.append("scope_type = ?")
+        params.append(clean_scope)
+    if clean_status:
+        clauses.append("status = ?")
+        params.append(clean_status)
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    rows = conn.execute(
+        f"""SELECT * FROM goal_profiles
+            {where}
+            ORDER BY
+              CASE scope_type
+                WHEN 'default' THEN 0
+                WHEN 'area' THEN 1
+                WHEN 'task_type' THEN 2
+                WHEN 'goal_id' THEN 3
+                ELSE 9
+              END,
+              profile_id ASC
+            LIMIT ?""",
+        params + [max(1, int(limit))],
+    ).fetchall()
+    return [_row_to_goal_profile(row) for row in rows if row]
+
+
+def upsert_goal_profile(
+    *,
+    profile_id: str,
+    profile_name: str = "",
+    description: str = "",
+    scope_type: str = "default",
+    scope_value: str = "",
+    goal_labels=None,
+    weights=None,
+    status: str = "active",
+    source: str = "manual",
+) -> dict:
+    ensure_default_goal_profiles()
+    clean_id = (profile_id or "").strip()
+    if not clean_id:
+        raise ValueError("profile_id is required")
+    clean_scope = (scope_type or "default").strip()
+    if clean_scope not in VALID_SCOPE_TYPES:
+        raise ValueError(f"scope_type must be one of: {', '.join(sorted(VALID_SCOPE_TYPES))}")
+    clean_status = (status or "active").strip().lower()
+    if clean_status not in VALID_STATUSES:
+        raise ValueError(f"status must be one of: {', '.join(sorted(VALID_STATUSES))}")
+
+    normalized_weights = _normalize_weights(weights)
+    normalized_labels = _normalize_goal_labels(goal_labels)
+    conn = get_db()
+    existing = conn.execute(
+        "SELECT * FROM goal_profiles WHERE profile_id = ?",
+        (clean_id,),
+    ).fetchone()
+    if existing:
+        current = dict(existing)
+        conn.execute(
+            """UPDATE goal_profiles
+               SET profile_name = ?,
+                   description = ?,
+                   scope_type = ?,
+                   scope_value = ?,
+                   goal_labels = ?,
+                   weights = ?,
+                   status = ?,
+                   source = ?,
+                   updated_at = datetime('now')
+               WHERE profile_id = ?""",
+            (
+                (profile_name or current.get("profile_name") or clean_id).strip(),
+                (description or current.get("description") or "").strip(),
+                clean_scope,
+                (scope_value or current.get("scope_value") or "").strip().lower(),
+                json.dumps(normalized_labels or _normalize_goal_labels(current.get("goal_labels")), ensure_ascii=False),
+                json.dumps(normalized_weights, ensure_ascii=False),
+                clean_status,
+                (source or current.get("source") or "manual").strip(),
+                clean_id,
+            ),
+        )
+    else:
+        conn.execute(
+            """INSERT INTO goal_profiles (
+                   profile_id, profile_name, description, scope_type, scope_value,
+                   goal_labels, weights, status, source
+               ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                clean_id,
+                (profile_name or clean_id).strip(),
+                (description or "").strip(),
+                clean_scope,
+                (scope_value or "").strip().lower(),
+                json.dumps(normalized_labels, ensure_ascii=False),
+                json.dumps(normalized_weights, ensure_ascii=False),
+                clean_status,
+                (source or "manual").strip(),
+            ),
+        )
+    conn.commit()
+    return get_goal_profile(clean_id) or {}
+
+
+def resolve_goal_profile(
+    *,
+    profile_id: str = "",
+    area: str = "",
+    task_type: str = "",
+    goal_id: str = "",
+) -> dict:
+    ensure_default_goal_profiles()
+    conn = get_db()
+    explicit_id = (profile_id or "").strip()
+    if explicit_id:
+        explicit = get_goal_profile(explicit_id)
+        if not explicit:
+            raise ValueError(f"Unknown goal profile: {explicit_id}")
+        if explicit.get("status") != "active":
+            raise ValueError(f"Goal profile {explicit_id} is not active")
+        explicit["resolved_by"] = "explicit"
+        return explicit
+
+    clean_goal_id = (goal_id or "").strip()
+    if clean_goal_id:
+        workflow_goal = get_workflow_goal(clean_goal_id)
+        if workflow_goal:
+            shared_state = workflow_goal.get("shared_state") or {}
+            shared_profile_id = str(shared_state.get("goal_profile_id", "")).strip()
+            if shared_profile_id:
+                linked = get_goal_profile(shared_profile_id)
+                if linked and linked.get("status") == "active":
+                    linked["resolved_by"] = "workflow_goal.shared_state"
+                    return linked
+        row = conn.execute(
+            """SELECT * FROM goal_profiles
+               WHERE scope_type = 'goal_id' AND scope_value = ? AND status = 'active'
+               ORDER BY updated_at DESC, profile_id ASC
+               LIMIT 1""",
+            (clean_goal_id,),
+        ).fetchone()
+        if row:
+            return _row_to_goal_profile(row, resolved_by="goal_id") or {}
+
+    clean_area = (area or "").strip().lower()
+    if clean_area:
+        row = conn.execute(
+            """SELECT * FROM goal_profiles
+               WHERE scope_type = 'area' AND scope_value = ? AND status = 'active'
+               ORDER BY updated_at DESC, profile_id ASC
+               LIMIT 1""",
+            (clean_area,),
+        ).fetchone()
+        if row:
+            return _row_to_goal_profile(row, resolved_by="area") or {}
+
+    clean_type = (task_type or "").strip().lower()
+    if clean_type:
+        row = conn.execute(
+            """SELECT * FROM goal_profiles
+               WHERE scope_type = 'task_type' AND scope_value = ? AND status = 'active'
+               ORDER BY updated_at DESC, profile_id ASC
+               LIMIT 1""",
+            (clean_type,),
+        ).fetchone()
+        if row:
+            return _row_to_goal_profile(row, resolved_by="task_type") or {}
+
+    row = conn.execute(
+        """SELECT * FROM goal_profiles
+           WHERE scope_type = 'default' AND status = 'active'
+           ORDER BY updated_at DESC, profile_id ASC
+           LIMIT 1"""
+    ).fetchone()
+    return _row_to_goal_profile(row, resolved_by="default") or {
+        "profile_id": "default_balanced",
+        "profile_name": "Balanced default",
+        "description": DEFAULT_GOAL_PROFILES[0]["description"],
+        "scope_type": "default",
+        "scope_value": "",
+        "goal_labels": list(DEFAULT_GOAL_PROFILES[0]["goal_labels"]),
+        "weights": dict(DEFAULT_WEIGHTS),
+        "status": "active",
+        "source": "system",
+        "resolved_by": "fallback_default",
+    }