openreflex 0.9.2__tar.gz → 0.9.4__tar.gz

{openreflex-0.9.2/src/openreflex.egg-info → openreflex-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openreflex
-Version: 0.9.2
+Version: 0.9.4
 Summary: Ambient project muscle memory for AI coding agents: learns and reuses project Reflexes automatically
 Author: vishnu-77
 License-Expression: MIT

{openreflex-0.9.2 → openreflex-0.9.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "openreflex"
-version = "0.9.2"
+version = "0.9.4"
 description = "Ambient project muscle memory for AI coding agents: learns and reuses project Reflexes automatically"
 readme = "README.md"
 license = "MIT"

{openreflex-0.9.2 → openreflex-0.9.4}/src/openreflex/__init__.py

@@ -1,3 +1,3 @@
 """Ambient, local execution intelligence."""
 
-__version__ = "0.9.2"
+__version__ = "0.9.4"

openreflex-0.9.4/src/openreflex/claude_ui.py

@@ -0,0 +1,186 @@
+"""Claude Code presentation integration.
+
+OpenReflex owns a user-level status line, never a project-level statusLine entry.
+Legacy OpenReflex project entries are migrated away without touching user-owned settings.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+LEGACY_STATUSLINE_COMMAND = "openreflex statusline"
+
+
+def statusline_command() -> str:
+    """Return the runtime-owned statusline command.
+
+    Plugin-managed runtimes pass OPENREFLEX_RUNTIME_COMMAND so the status line cannot
+    resolve an unrelated or stale global `openreflex` executable from PATH.
+    """
+    runtime = os.environ.get("OPENREFLEX_RUNTIME_COMMAND", "").strip()
+    return f"{runtime} statusline" if runtime else LEGACY_STATUSLINE_COMMAND
+
+
+def claude_settings_path() -> Path:
+    """Return Claude Code's user-level settings path.
+
+    CLAUDE_CONFIG_DIR is respected so alternate Claude profiles and isolated tests do
+    not fall back to the real user home directory.
+    """
+    configured = os.environ.get("CLAUDE_CONFIG_DIR", "").strip()
+    root = Path(configured).expanduser() if configured else Path.home() / ".claude"
+    return root / "settings.json"
+
+
+def _ours(command: object) -> bool:
+    if not isinstance(command, str):
+        return False
+    value = command.replace("\\", "/").lower()
+    return command == LEGACY_STATUSLINE_COMMAND or (
+        ".openreflex/runtime/" in value and value.rstrip().endswith(" statusline")
+    )
+
+
+def _owned_project_hook(entry: object) -> bool:
+    """True only for hook entries installed by OpenReflex into project settings."""
+    value = json.dumps(entry, default=str).replace("\\\\", "/").lower()
+    return (
+        "openreflex hook claude-code" in value
+        or ("runtime/launcher.cjs" in value and " hook claude-code " in value)
+    )
+
+
+def _load(path: Path) -> dict | None:
+    if not path.exists():
+        return {}
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def _write(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temp = path.with_suffix(path.suffix + ".tmp")
+    temp.write_text(json.dumps(data, indent=2) + "\n", encoding="utf-8")
+    os.replace(temp, path)
+
+
+def _remove_owned_statusline(path: Path, *, delete_empty: bool = False) -> bool:
+    data = _load(path)
+    if data is None:
+        return False
+    current = data.get("statusLine")
+    if not isinstance(current, dict) or not _ours(current.get("command")):
+        return False
+
+    data.pop("statusLine", None)
+    if delete_empty and not data:
+        try:
+            path.unlink()
+        except FileNotFoundError:
+            pass
+        try:
+            path.parent.rmdir()
+        except OSError:
+            pass
+    else:
+        _write(path, data)
+    return True
+
+
+def remove_project_integration(project: Path) -> bool:
+    """Remove legacy OpenReflex-owned Claude project config, preserving user config.
+
+    The Claude plugin is user-scoped and must not require repository-local Claude
+    settings. Older OpenReflex releases could leave a project statusLine or hook entries
+    behind; remove only those entries and delete the file/directory when it becomes empty.
+    """
+    path = project / ".claude" / "settings.json"
+    data = _load(path)
+    if data is None or not path.exists():
+        return False
+
+    changed = False
+    current = data.get("statusLine")
+    if isinstance(current, dict) and _ours(current.get("command")):
+        data.pop("statusLine", None)
+        changed = True
+
+    hooks = data.get("hooks")
+    if isinstance(hooks, dict):
+        cleaned = {}
+        for event, entries in hooks.items():
+            if not isinstance(entries, list):
+                cleaned[event] = entries
+                continue
+            kept = [entry for entry in entries if not _owned_project_hook(entry)]
+            if kept:
+                cleaned[event] = kept
+            if len(kept) != len(entries):
+                changed = True
+        if cleaned:
+            data["hooks"] = cleaned
+        elif "hooks" in data:
+            data.pop("hooks", None)
+
+    if not changed:
+        return False
+
+    if not data:
+        try:
+            path.unlink()
+        except FileNotFoundError:
+            pass
+        try:
+            path.parent.rmdir()
+        except OSError:
+            pass
+    else:
+        _write(path, data)
+    return True
+
+
+def remove_project_statusline(project: Path) -> bool:
+    """Backward-compatible cleanup entry point for legacy callers."""
+    return remove_project_integration(project)
+
+
+def configure_statusline(project: Path | None = None) -> str:
+    """Configure the OpenReflex status line in Claude's user settings.
+
+    A project argument is accepted because session hooks know the active project. It is
+    used only to migrate a legacy OpenReflex-owned project statusLine entry; the desired
+    status line is always written to the user scope.
+    """
+    if project is not None:
+        remove_project_integration(project)
+
+    path = claude_settings_path()
+    data = _load(path)
+    if data is None:
+        return "preserved-invalid"
+
+    existing = data.get("statusLine")
+    desired = statusline_command()
+    if isinstance(existing, dict):
+        current = existing.get("command")
+        if current == desired:
+            return "already-configured"
+        if not _ours(current):
+            return "preserved-existing"
+        data["statusLine"] = {**existing, "command": desired, "padding": 0, "refreshInterval": 2}
+        _write(path, data)
+        return "updated-runtime"
+
+    data["statusLine"] = {"type": "command", "command": desired, "padding": 0, "refreshInterval": 2}
+    _write(path, data)
+    return "configured"
+
+
+def remove_statusline() -> bool:
+    """Remove only the OpenReflex-owned user-level status line."""
+    return _remove_owned_statusline(claude_settings_path())

{openreflex-0.9.2 → openreflex-0.9.4}/src/openreflex/cli.py

@@ -149,8 +149,14 @@ def cmd_status(args) -> int:
     print(f"OpenReflex {__version__} - {project}")
     print(f"  enabled: {data['enabled']}   agents: {', '.join(data['engagement']['agents']) or '-'}")
     print(f"  tasks: {data['engagement']['tasks']}   experiences: {data['engagement']['experiences']}   lessons: {data['lessons']}")
-    print(f"  project reflexes: {data['project_reflexes']['visible']} "
-          f"({data['project_reflexes']['learned']} learned / {data['project_reflexes']['proven']} proven)")
+    reflexes = data["project_reflexes"]
+    print(f"  project reflex: {reflexes['project_state']} · {reflexes['project_support']} supporting experience(s)")
+    specialised = []
+    for key in ("learning", "learned", "proven", "stale"):
+        count = int(reflexes.get(key, 0) or 0)
+        if count:
+            specialised.append(f"{count} {key}")
+    print("  specialised reflexes: " + (" / ".join(specialised) if specialised else "learning from project evidence"))
     print(f"  first session captured: {data['activation']['first_session_captured']}   "
           f"seconds to first task: {data['activation']['seconds_to_first_task']}")
     print(f"  tasks that used prior experience: {reuse['benefit_rate']}")

{openreflex-0.9.2 → openreflex-0.9.4}/src/openreflex/entrypoint.py

@@ -18,7 +18,7 @@ from pathlib import Path
 from typing import Callable, TypeVar
 
 from . import __version__, cli
-from .claude_ui import configure_statusline, remove_statusline
+from .claude_ui import configure_statusline, remove_project_integration
 from .project import approval, approve, log_error, project_root
 from .project_map import enrich_snapshot
 from .project_memory import ensure_background_refresh, load_snapshot, read_state, run_worker, update_state
@@ -468,18 +468,21 @@ def _compact_overview(project: Path, plugin_root: str | None = None) -> int:
     task = state.get("task") if isinstance(state.get("task"), dict) else {}
     reflex_name = str(task.get("reflex") or "").strip()
 
-    reflex_count = 0
+    reflex_state = "cold"
+    reflex_support = 0
     if enabled:
         try:
-            from .reflexes import visible_reflexes
+            from .reflexes import reflex_summary
             from .store import Store, database_path
             store = Store(database_path(project))
             try:
-                reflex_count = len(visible_reflexes(store))
+                summary = reflex_summary(store)
+                reflex_state = str(summary["project_state"])
+                reflex_support = int(summary["project_support"])
             finally:
                 store.close()
         except Exception:  # noqa: BLE001 - overview must remain available if optional detail fails
-            reflex_count = 0
+            reflex_state = "learning"
 
     state_label = "READY" if enabled and aligned else "SETUP" if not enabled else "ATTENTION"
     print(f"OPENREFLEX {__version__}                              {state_label}")
@@ -487,8 +490,11 @@ def _compact_overview(project: Path, plugin_root: str | None = None) -> int:
     print(f"Project      {project.name}")
     if enabled:
         experiences = int(state.get("experiences", 0) or 0)
-        print(f"Memory       {experiences} experiences · {reflex_count} Reflexes")
-        print(f"Current      {reflex_name or ('learning' if experiences else 'learning project')}")
+        reflex_label = reflex_state if experiences else "warming"
+        print(f"Memory       {experiences} experiences · Project Reflex {reflex_label}")
+        if reflex_support:
+            print(f"Evidence     {reflex_support} supporting experience(s)")
+        print(f"Current      {reflex_name or ('Project Reflex · ' + reflex_label)}")
     else:
         print("Memory       not enabled")
     print(f"Runtime      {'aligned' if aligned else f'plugin {plugin_version} / runtime {runtime_version}'}")
@@ -564,8 +570,10 @@ def _onboard(argv: list[str]) -> int:
     print("  memory      enabled · local")
     if status == "preserved-existing":
         print("  statusline  existing user status line preserved")
+    elif status == "preserved-invalid":
+        print("  statusline  user settings unreadable; preserved unchanged")
     else:
-        print("  statusline  managed OpenReflex runtime")
+        print("  statusline  managed OpenReflex runtime · user scope")
     print("")
     print(dashboard(project))
     return 0
@@ -610,33 +618,35 @@ def _memory(argv: list[str]) -> int:
 
 
 def _reflexes(argv: list[str]) -> int:
-    from .reflexes import visible_reflexes
+    from .reflexes import display_reflexes, display_state
     from .store import Store, database_path
 
     if argv and argv[0] in {"-h", "--help"}:
         print("usage: openreflex reflexes [--project PATH]\n")
-        print("Show learned and proven project-specific Reflex procedures.")
+        print("Show the project Reflex and specialised Reflexes, including active learning.")
         return 0
     project = project_root(_project_arg(argv))
     store = Store(database_path(project))
     try:
-        reflexes = visible_reflexes(store)
+        reflexes = display_reflexes(store)
     finally:
         store.close()
     print("OPENREFLEX / PROJECT REFLEXES")
     print(f"  project     {project}")
     if not reflexes:
-        print("  state       learning")
-        print("  reflexes    none learned yet")
+        print("  state       warming")
+        print("  reflex      starts with the first captured experience")
         return 0
     for reflex in reflexes:
         print("")
         print(f"  {reflex.name}")
-        print(f"    state     {reflex.state}")
+        print(f"    state     {display_state(reflex)}")
         print(f"    evidence  {reflex.success_count} successful / {reflex.verified_count} verified")
-        if reflex.family.startswith("area:"):
+        if reflex.family == "project-root":
+            print("    scope     whole project · cross-task · cross-mode")
+        elif reflex.family.startswith("area:"):
             print("    scope     cross-task project area")
-        else:
+        elif reflex.procedure:
             print(f"    steps     {' -> '.join(reflex.procedure)}")
     return 0
 
@@ -694,14 +704,16 @@ def _augment_install(argv: list[str], result: int) -> None:
         print(f"  statusline  OpenReflex v{__version__} enabled")
     elif status == "preserved-existing":
         print("  statusline  existing user status line preserved")
+    elif status == "preserved-invalid":
+        print("  statusline  user settings unreadable; preserved unchanged")
 
 
 def _augment_uninstall(argv: list[str], result: int) -> None:
     if result != 0 or len(argv) < 2 or argv[1] != "claude-code" or "--dry-run" in argv:
         return
     project = project_root(_project_arg(argv))
-    if remove_statusline(project):
-        print("  statusline  OpenReflex status line removed")
+    if remove_project_integration(project):
+        print("  project     legacy OpenReflex Claude config removed")
 
 
 def main(argv: list[str] | None = None) -> int:

{openreflex-0.9.2 → openreflex-0.9.4}/src/openreflex/mcp_server.py

@@ -20,7 +20,7 @@ from .mcp_contracts import (
     SearchExperienceResult,
 )
 from .project import approval, approve, project_root
-from .reflexes import visible_reflexes
+from .reflexes import display_reflexes, display_state
 from .routing import Limits
 
 INSTRUCTIONS = """OpenReflex runs ambiently through lifecycle hooks. Normal coding-agent work does not require
@@ -208,26 +208,28 @@ def build_server(project: Path) -> FastMCP:
 
     @tool("Get project Reflexes", READ)
     def get_project_reflexes() -> str:
-        """Show the project-specific procedures OpenReflex has learned from repeated successful work.
-        Returns: a compact list of learned/proven Reflex names, lifecycle state, support/verification counts and
-        procedure steps. Candidate procedures from a single run are intentionally hidden until repeated evidence
-        promotes them.
+        """Show the project Reflex and specialised procedures OpenReflex is learning from repeated work.
+        Returns: the root Project Reflex after the first captured experience, plus specialised Reflexes with
+        learning/learned/proven/stale maturity, support/verification counts and procedure steps.
         Use when: the user asks what OpenReflex has learned specifically about this project, which reusable procedures
         exist, or how a named Reflex works.
         Not for: backend routing internals or generic strategies (use get_candidate_paths for those diagnostics).
         Side effects: none; read-only. It never recompiles memory or touches project files.
         Errors: a 'not enabled' message is returned until the project is approved."""
         def operation(e: Engine):
-            reflexes = visible_reflexes(e.store)
+            reflexes = display_reflexes(e.store)
             if not reflexes:
-                return "OPENREFLEX / PROJECT REFLEXES\n\nNo learned project Reflexes yet."
+                return "OPENREFLEX / PROJECT REFLEXES\n\nProject Reflex warming · capture the first substantial task."
             lines = ["OPENREFLEX / PROJECT REFLEXES", ""]
             for reflex in reflexes:
                 lines.append(
-                    f"{reflex.name} · {reflex.state} · {reflex.success_count} successful · "
+                    f"{reflex.name} · {display_state(reflex)} · {reflex.support_count} supporting · {reflex.success_count} successful · "
                     f"{reflex.verified_count} verified"
                 )
-                lines.append("  " + " -> ".join(reflex.procedure))
+                if reflex.family == "project-root":
+                    lines.append("  scope: whole project · cross-task · cross-mode")
+                elif reflex.procedure:
+                    lines.append("  " + " -> ".join(reflex.procedure))
             return "\n".join(lines)
         return run(operation)
 

{openreflex-0.9.2 → openreflex-0.9.4}/src/openreflex/metrics.py

@@ -11,6 +11,7 @@ from statistics import mean
 
 from .engine import Engine
 from .learning import realized_utility
+from .reflexes import reflex_summary
 
 WEEK = 604800
 
@@ -47,8 +48,7 @@ def project_metrics(engine: Engine, approval_record: dict | None = None, now: fl
     executions = store.list("Execution", limit=100_000)
     experiences = sorted(store.list("Experience", limit=100_000), key=lambda x: x.created_at)
     contexts = {c.task_id: c for c in store.list("Context", limit=100_000)}
-    reflexes = store.list_reflexes(states=("learned", "proven"), limit=100_000)
-    reflex_states = Counter(item.state for item in reflexes)
+    reflexes = reflex_summary(store)
     task_by_id = {t.id: t for t in tasks}
     approved_at = (approval_record or {}).get("approved_at")
 
@@ -164,7 +164,15 @@ def project_metrics(engine: Engine, approval_record: dict | None = None, now: fl
         "execution_control": {"verdicts": dict(verdicts),
                               "success_after_pivot_or_stop": _avg(x.status == "success" for x in advised),
                               "tasks_within_tool_call_budget": _avg(within_budget)},
-        "project_reflexes": {"visible": len(reflexes), "learned": reflex_states["learned"],
-                             "proven": reflex_states["proven"]},
+        "project_reflexes": {
+            "visible": reflexes["visible"],
+            "project_state": reflexes["project_state"],
+            "project_support": reflexes["project_support"],
+            "specialised_total": reflexes["specialised_total"],
+            "learning": reflexes["learning"],
+            "learned": reflexes["learned"],
+            "proven": reflexes["proven"],
+            "stale": reflexes["stale"],
+        },
         "lessons": len(store.list("Lesson", limit=100_000)),
     }

{openreflex-0.9.2 → openreflex-0.9.4}/src/openreflex/reflex_index.py

@@ -18,6 +18,7 @@ from pathlib import Path
 
 from .engine import Engine
 from .project_memory import load_snapshot, snapshot_path, update_state
+from .reflexes import reflex_summary
 
 ROLE_BONUS = {
     "helm-config": 5.0,
@@ -91,18 +92,24 @@ def _evidence_state(item: dict) -> str:
     return "discovered"
 
 
-def _counts(engine: Engine) -> dict[str, int]:
+def _counts(engine: Engine) -> dict[str, object]:
     outcomes = engine.store.count("Outcome")
     unknown = engine.store.count("Outcome", "status", "unknown")
+    reflexes = reflex_summary(engine.store)
     return {
         "experiences": engine.store.count("Experience"),
         "verified": engine.store.count("Outcome", "verified", True),
         "known_outcomes": outcomes - unknown,
         "lessons": engine.store.count("Lesson"),
+        "project_reflex_state": reflexes["project_state"],
+        "project_reflex_support": reflexes["project_support"],
+        "reflexes_learning": reflexes["learning"],
+        "reflexes_learned": reflexes["learned"],
+        "reflexes_proven": reflexes["proven"],
     }
 
 
-def sync_counts(project: Path) -> dict[str, int]:
+def sync_counts(project: Path) -> dict[str, object]:
     """Refresh lightweight UI counts from the local Experience Graph."""
     engine = Engine(project)
     try:

{openreflex-0.9.2 → openreflex-0.9.4}/src/openreflex/reflexes.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import hashlib
 import math
 import re
+import time
 from collections import Counter
 from pathlib import PurePosixPath
 
@@ -13,6 +14,7 @@ from .routing import embed, similarity
 from .store import Store
 
 _VISIBLE_STATES = ("learned", "proven")
+PROJECT_ROOT_FAMILY = "project-root"
 _STOPWORDS = {
     "the", "a", "an", "and", "or", "to", "for", "in", "on", "of", "this", "that", "with", "from",
     "please", "project", "repo", "repository", "change", "update", "fix", "add", "make", "work",
@@ -62,11 +64,13 @@ def _query_hints(text: str) -> set[str]:
 
 
 def _scope_specificity(family: str) -> int:
-    """Deterministic tie-break: concrete technology/file scopes beat broad semantic scopes."""
+    """Deterministic tie-break: concrete scopes beat the always-present project root."""
     if family in {"helm-values", "helm-chart", "helm-template", "terraform", "ci", "database", "dependencies", "tests"}:
         return 3
     if family.startswith("area:"):
         return 2
+    if family == PROJECT_ROOT_FAMILY:
+        return 0
     return 1
 
 
@@ -138,6 +142,9 @@ def families_for_experience(experience: Experience) -> tuple[str, ...]:
 
     if not families:
         add(f"{experience.task_mode}-{experience.task_class}")
+    # Every meaningful execution also reinforces one cross-mode project Reflex.
+    # Specialised families remain first so existing primary-family behaviour is preserved.
+    add(PROJECT_ROOT_FAMILY)
     return tuple(families)
 
 
@@ -147,6 +154,8 @@ def _family(experience: Experience) -> str:
 
 
 def _name(family: str, experience: Experience) -> str:
+    if family == PROJECT_ROOT_FAMILY:
+        return "Project Reflex"
     if family.startswith("area:"):
         words = family.removeprefix("area:").replace("-", " ")
         return f"{words.capitalize()} work"
@@ -282,14 +291,14 @@ def _confidence(known: int, successes: int, verified: int) -> float:
 
 
 def _compile_family(store: Store, experience: Experience, family: str, now: float) -> ProjectReflex:
-    project_area = family.startswith("area:")
-    group = [
+    project_scope = family.startswith("area:") or family == PROJECT_ROOT_FAMILY
+    observed_group = [
         item for item in store.list("Experience", limit=5000)
-        if (project_area or item.task_mode == experience.task_mode)
+        if (project_scope or item.task_mode == experience.task_mode)
         and family in families_for_experience(item)
-        and item.status != "unknown"
     ]
-    group.sort(key=lambda item: item.created_at)
+    observed_group.sort(key=lambda item: item.created_at)
+    group = [item for item in observed_group if item.status != "unknown"]
     successes = [item for item in group if item.status == "success"]
     verified = 0
     for item in successes:
@@ -299,7 +308,7 @@ def _compile_family(store: Store, experience: Experience, family: str, now: floa
             continue
         verified += int(bool(getattr(outcome, "verified", False)))
 
-    reflex_mode = "project" if project_area else experience.task_mode
+    reflex_mode = "project" if project_scope else experience.task_mode
     key = f"{reflex_mode}|{family}"
     reflex_id = "reflex-" + hashlib.sha1(key.encode()).hexdigest()[:16]
     try:
@@ -323,11 +332,11 @@ def _compile_family(store: Store, experience: Experience, family: str, now: floa
         task_class=primary_class,
         state=_state(len(group), len(successes), verified, previous_state),
         seed_strategy=seed_strategy,
-        # Project-area Reflexes are cross-mode scope memory, not an execution recipe. Replaying a BUILD
-        # procedure into a THINK/docs task would be actively misleading; mode-specific Reflexes keep procedures.
-        procedure=[] if project_area else _procedure(store, successes or group or [experience]),
-        evidence_ids=[item.id for item in group[-20:]],
-        support_count=len(group),
+        # Project-wide and project-area Reflexes are cross-mode memory, not one task recipe.
+        # Mode-specific specialised Reflexes keep executable procedures.
+        procedure=[] if project_scope else _procedure(store, successes or group or [experience]),
+        evidence_ids=[item.id for item in (observed_group if family == PROJECT_ROOT_FAMILY else group)[-20:]],
+        support_count=len(observed_group) if family == PROJECT_ROOT_FAMILY else len(group),
         success_count=len(successes),
         verified_count=verified,
         confidence=_confidence(len(group), len(successes), verified),
@@ -348,6 +357,58 @@ def compile_for_experience(store: Store, experience: Experience, now: float) ->
     return compiled[0]
 
 
+def ensure_project_reflex(store: Store, now: float | None = None) -> ProjectReflex | None:
+    """Backfill/update the root project Reflex from all captured experiences.
+
+    Older OpenReflex versions did not compile a root project Reflex. Reading a project
+    summary is therefore also a safe migration point: existing execution evidence is
+    consolidated without inventing success or verification.
+    """
+    experiences = sorted(store.list("Experience", limit=5000), key=lambda item: item.created_at)
+    if not experiences:
+        return None
+    latest = experiences[-1]
+    return _compile_family(store, latest, PROJECT_ROOT_FAMILY, time.time() if now is None else now)
+
+
+def display_state(reflex: ProjectReflex) -> str:
+    """User-facing maturity: a candidate means learning is actively underway."""
+    return "learning" if reflex.state == "candidate" else reflex.state
+
+
+def display_reflexes(store: Store) -> list[ProjectReflex]:
+    """Return the root Reflex plus specialised Reflexes, including learning candidates."""
+    root = ensure_project_reflex(store)
+    items = store.list_reflexes(limit=500)
+    ordered = []
+    if root is not None:
+        ordered.append(root)
+    ordered.extend(
+        item for item in items
+        if (root is None or item.id != root.id) and item.state in {"candidate", "learned", "proven", "stale"}
+    )
+    return ordered
+
+
+def reflex_summary(store: Store) -> dict[str, object]:
+    """Summarise project learning without collapsing active learning to a misleading zero."""
+    items = display_reflexes(store)
+    root = next((item for item in items if item.family == PROJECT_ROOT_FAMILY), None)
+    specialised = [item for item in items if item.family != PROJECT_ROOT_FAMILY]
+    states = Counter(display_state(item) for item in specialised)
+    return {
+        "project": root,
+        "project_state": display_state(root) if root is not None else "cold",
+        "project_support": root.support_count if root is not None else 0,
+        "visible": len(items),
+        "specialised_total": len(specialised),
+        "learning": states["learning"],
+        "learned": states["learned"],
+        "proven": states["proven"],
+        "stale": states["stale"],
+    }
+
+
 def _reflex_family(reflex: ProjectReflex) -> str:
     if reflex.family:
         return reflex.family
@@ -379,8 +440,11 @@ def _locality(description: str, reflex: ProjectReflex) -> float:
 def match_reflex(store: Store, description: str, task_mode: str, task_class: str,
                  threshold: float = 0.28, family_hints: set[str] | None = None) -> tuple[ProjectReflex, float] | None:
     """Resolve the strongest project Reflex using intent, family, locality and execution evidence."""
+    ensure_project_reflex(store)
     query = embed(description)
     hints = _query_hints(description) | set(family_hints or ())
+    # The project root is a baseline, not an intent hint; specific area/procedure Reflexes should win.
+    hints.discard(PROJECT_ROOT_FAMILY)
     scored: list[tuple[ProjectReflex, float]] = []
 
     for reflex in store.list_reflexes(states=_VISIBLE_STATES, limit=500):

{openreflex-0.9.2 → openreflex-0.9.4}/src/openreflex/tui.py

@@ -226,8 +226,9 @@ def dashboard(project: Path, *, colour: bool | None = None) -> str:
               f"  verified         {state.get('verified', 0)}",
               f"  lessons          {state.get('lessons', 0)}",
               "", "CURRENT REFLEX",
-              f"  name             {task.get('reflex') or 'learning project procedure'}",
-              f"  state            {task.get('reflex_state') or '-'}",
+              f"  name             {task.get('reflex') or 'Project Reflex'}",
+              f"  state            {task.get('reflex_state') or state.get('project_reflex_state') or ('learning' if state.get('experiences') else 'warming')}",
+              f"  support          {state.get('project_reflex_support', 0)} project experience(s)",
               f"  phase            {phase.upper()}",
               f"  mode             {str(task.get('mode') or 'build').upper()}",
               f"  recall           {recall.get('experiences', 0)} related",

{openreflex-0.9.2 → openreflex-0.9.4/src/openreflex.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: openreflex
-Version: 0.9.2
+Version: 0.9.4
 Summary: Ambient project muscle memory for AI coding agents: learns and reuses project Reflexes automatically
 Author: vishnu-77
 License-Expression: MIT