@event4u/agent-config 6.1.0 → 7.0.0

package/dist/agent-src/templates/scripts/work_engine/scoring/memory_visibility.py

@@ -1,283 +0,0 @@
-"""Producer-side helpers for the memory-visibility line.
-
-Implements the v1 line shape from
-``docs/contracts/memory-visibility-v1.md``:
-
-    🧠 Memory: <hits>/<asks> · ids=[<comma-separated-ids>]
-    🧠 Memory: <hits>/<asks> · ids=[<...>] · affected: <keys>
-
-The optional ``· affected: <keys>`` trailing segment surfaces which
-closed-list decision-trace keys diverged because memory was
-consulted — see ``docs/contracts/decision-trace-v1.md`` "Memory
-consequence keys".
-
-The semantics matched to the work-engine model:
-
-* The ``memory`` step retrieves across the four allowed memory types
-  (``MEMORY_TYPES`` in ``directives.backend.memory``). Each type is
-  one ``ask`` from the visibility-line perspective.
-* ``hits`` counts distinct types that returned at least one entry.
-* ``ids`` is the deduped list of returned entry ids preserving the
-  retrieval order encoded in ``state.memory``.
-
-Privacy floor: this module never emits entry bodies, summaries,
-``path``/``source`` fields, or anything beyond ``id`` and ``type``.
-The privacy regression test (``tests/contracts/test_memory_
-visibility_redaction.py``) keeps this guarantee enforced.
-"""
-from __future__ import annotations
-
-from typing import Any, Iterable
-
-from .decision_trace import derive_confidence_band, derive_risk_class
-
-ICON = "\U0001F9E0"  # 🧠
-DEFAULT_MAX_INLINE_IDS = 5
-DEFAULT_ASKED_TYPES = (
-    "domain-invariants",
-    "incident-learnings",
-    "historical-patterns",
-)
-
-CONSEQUENCE_KEYS: tuple[str, ...] = (
-    "confidence_band",
-    "risk_class",
-    "applied_rules",
-    "test_plan",
-)
-
-
-def summarise_visibility(
-    memory: Any,
-    *,
-    asked_types: Iterable[str] = DEFAULT_ASKED_TYPES,
-) -> dict[str, Any]:
-    """Reduce ``state.memory`` into the visibility-line slice.
-
-    ``memory`` is the list of hit dicts produced by
-    ``directives.backend.memory``. Returns ``{"asks", "hits", "ids"}``
-    with privacy-safe values only.
-    """
-    asked = tuple(asked_types)
-    if not memory or not isinstance(memory, list):
-        return {"asks": 0, "hits": 0, "ids": []}
-    asks = len(asked)
-    seen_types: set[str] = set()
-    ids: list[str] = []
-    seen_ids: set[str] = set()
-    for entry in memory:
-        if not isinstance(entry, dict):
-            continue
-        type_value = entry.get("type")
-        if isinstance(type_value, str):
-            seen_types.add(type_value)
-        entry_id = entry.get("id") or entry.get("rule_id")
-        if not isinstance(entry_id, (str, int)):
-            continue
-        sid = str(entry_id)
-        if sid in seen_ids:
-            continue
-        seen_ids.add(sid)
-        ids.append(sid)
-    hits = len(seen_types) if seen_types else (1 if ids else 0)
-    return {"asks": asks, "hits": hits, "ids": ids}
-
-
-def _normalise_key_value(value: Any) -> Any:
-    """Return a comparable shape for a consequence-key value.
-
-    List-shaped keys (``applied_rules``, ``test_plan``) compare as
-    sorted tuples so order is not a divergence; scalar keys
-    (``confidence_band``, ``risk_class``) compare as-is.
-    """
-    if isinstance(value, list):
-        return tuple(sorted(str(item) for item in value))
-    return value
-
-
-def diff_consequence_keys(
-    trace_with: dict[str, Any], trace_without: dict[str, Any],
-) -> list[str]:
-    """Return sorted keys whose values diverge between two traces.
-
-    Iterates the closed ``CONSEQUENCE_KEYS`` list defined in
-    ``docs/contracts/decision-trace-v1.md``. A key is considered
-    *diverged* when its normalised value differs between the two
-    traces. Per the contract, when both sides are ``None`` the key
-    is suppressed from the diff entirely.
-    """
-    affected: list[str] = []
-    for key in CONSEQUENCE_KEYS:
-        a = trace_with.get(key)
-        b = trace_without.get(key)
-        if a is None and b is None:
-            continue
-        if _normalise_key_value(a) != _normalise_key_value(b):
-            affected.append(key)
-    return sorted(affected)
-
-
-def compute_affected(
-    *,
-    memory_hits: int,
-    verify_claims: int = 0,
-    verify_first_try_passes: int = 0,
-    ambiguity_flag: bool = False,
-    changes: Any = None,
-    applied_rules: list[str] | None = None,
-    test_plan: list[str] | None = None,
-) -> list[str] | None:
-    """Compute the ``affected`` consequence keys for the visibility line.
-
-    Returns:
-        * ``None`` when no memory was consulted (``memory_hits <= 0``)
-          — caller MUST omit the ``· affected: …`` segment.
-        * ``[]`` when memory was consulted but no closed-list key
-          diverged — caller MUST render ``· affected: none``.
-        * sorted list of keys otherwise.
-
-    The counterfactual trace is "what the heuristics would have
-    emitted if ``memory_hits`` had been ``0``". v1 covers
-    ``confidence_band`` and ``risk_class`` via the existing scoring
-    helpers; ``applied_rules`` and ``test_plan`` pass through
-    unchanged because they are not yet memory-derived in the
-    engine — the keys stay in the closed list so the diff
-    infrastructure is in place when they wire in.
-    """
-    if memory_hits <= 0:
-        return None
-    trace_with = {
-        "confidence_band": derive_confidence_band(
-            memory_hits=memory_hits,
-            verify_claims=verify_claims,
-            verify_first_try_passes=verify_first_try_passes,
-            ambiguity_flag=ambiguity_flag,
-        ),
-        "risk_class": derive_risk_class(changes),
-        "applied_rules": list(applied_rules) if applied_rules else None,
-        "test_plan": list(test_plan) if test_plan else None,
-    }
-    trace_without = {
-        "confidence_band": derive_confidence_band(
-            memory_hits=0,
-            verify_claims=verify_claims,
-            verify_first_try_passes=verify_first_try_passes,
-            ambiguity_flag=ambiguity_flag,
-        ),
-        "risk_class": derive_risk_class(changes),
-        "applied_rules": list(applied_rules) if applied_rules else None,
-        "test_plan": list(test_plan) if test_plan else None,
-    }
-    return diff_consequence_keys(trace_with, trace_without)
-
-
-def format_line(
-    summary: dict[str, Any],
-    *,
-    max_inline_ids: int = DEFAULT_MAX_INLINE_IDS,
-    affected: list[str] | None = None,
-) -> str | None:
-    """Render the visibility line; return ``None`` when ``asks == 0``.
-
-    Cap inline ids at ``max_inline_ids`` and append ``…+N`` when the
-    list is longer. Returning ``None`` enforces the contract clause
-    "If ``asks == 0``, the engine MUST suppress the line entirely".
-
-    When ``affected`` is not ``None``, append the
-    ``· affected: <keys>`` trailing segment from
-    ``docs/contracts/memory-visibility-v1.md``: empty list renders as
-    ``affected: none`` (consulted but no key diverged);
-    non-empty list renders the comma-separated keys.
-    """
-    asks = int(summary.get("asks", 0) or 0)
-    if asks <= 0:
-        return None
-    hits = int(summary.get("hits", 0) or 0)
-    raw_ids = summary.get("ids") or []
-    ids = [str(i) for i in raw_ids if isinstance(i, (str, int))]
-    if max_inline_ids < 0:
-        max_inline_ids = 0
-    inline = ids[:max_inline_ids]
-    overflow = len(ids) - len(inline)
-    rendered_ids = ", ".join(inline)
-    if overflow > 0:
-        suffix = ", " if rendered_ids else ""
-        rendered_ids = f"{rendered_ids}{suffix}\u2026+{overflow}"
-    line = f"{ICON} Memory: {hits}/{asks} \u00b7 ids=[{rendered_ids}]"
-    if affected is not None:
-        rendered_affected = ",".join(affected) if affected else "none"
-        line = f"{line} \u00b7 affected: {rendered_affected}"
-    return line
-
-
-def format_changed_decisions_block(
-    ids: Iterable[str], affected: Iterable[str] | None,
-) -> str | None:
-    """Render the end-of-run "Memory changed decisions" report block.
-
-    Per ``docs/contracts/memory-visibility-v1.md``: lists
-    ``<id> → <key>`` rows derived from the same diff source as the
-    visibility line's ``affected`` segment. Returns ``None`` when
-    no key diverged (``affected`` empty / ``None``) so the caller
-    suppresses the block entirely.
-
-    Attribution in v1 is aggregate: each consulted id pairs with
-    each affected key. Per-id attribution is captured as a
-    follow-up risk in the roadmap Risk register.
-    """
-    if not affected:
-        return None
-    affected_list = sorted(affected)
-    id_list = [str(i) for i in ids if isinstance(i, (str, int))]
-    if not id_list:
-        return None
-    lines = ["Memory changed decisions:"]
-    for entry_id in id_list:
-        for key in affected_list:
-            lines.append(f"- {entry_id} \u2192 {key}")
-    return "\n".join(lines)
-
-
-def should_emit(
-    summary: dict[str, Any],
-    *,
-    memory_cadence: str = "always",
-    visibility_off: bool = False,
-) -> bool:
-    """Apply the cadence + opt-out gates from the contract.
-
-    ``memory_cadence`` is the ``memory.cadence`` cadence key:
-
-    * ``always`` (default) — emit whenever ``asks >= 1``.
-    * ``auto`` — emit only when ``asks >= 3`` (reduces noise on
-      shallow-retrieval steps).
-    * ``never`` — suppress the line entirely.
-
-    ``visibility_off`` is the legacy ``memory.visibility: off`` master
-    switch and still wins over any ``memory_cadence`` value.
-    """
-    if visibility_off:
-        return False
-    asks = int(summary.get("asks", 0) or 0)
-    if asks <= 0:
-        return False
-    status = (memory_cadence or "always").strip().lower()
-    if status == "never":
-        return False
-    if status == "auto":
-        return asks >= 3
-    return True
-
-
-__all__ = [
-    "CONSEQUENCE_KEYS",
-    "DEFAULT_ASKED_TYPES",
-    "DEFAULT_MAX_INLINE_IDS",
-    "ICON",
-    "compute_affected",
-    "diff_consequence_keys",
-    "format_changed_decisions_block",
-    "format_line",
-    "should_emit",
-    "summarise_visibility",
-]

package/dist/agent-src/templates/scripts/work_engine/stack/__init__.py

@@ -1,31 +0,0 @@
-"""Stack detection for the UI directive set (R3 Phase 1).
-
-The :mod:`work_engine.stack.detect` module sniffs the project root for
-manifest signals (``composer.json``, ``package.json``, ``components.json``)
-and labels the frontend stack one of:
-
-- ``blade-livewire-flux`` — Laravel + Livewire + Flux UI components
-- ``react-shadcn`` — React + Radix-based shadcn/ui primitives
-- ``vue`` — Vue.js (3.x or 2.x)
-- ``plain`` — none of the above; Tailwind + raw HTML/Blade fallback
-
-The label feeds the dispatcher's UI directive set (``directives/ui/apply.py``)
-to pick the right implementation skill.
-
-Detection is **manifest-only** by design — we do not read JS/PHP source
-files because:
-
-1. Manifests are deterministic and cheap to parse.
-2. Source-level signals (e.g. counting ``<x-flux::*`` calls) are noisy
-   on greenfield repos where audit will already emit ``greenfield=true``.
-3. Re-detect on manifest mtime change is sufficient — adding a stack
-   means editing a manifest, and we cache against that.
-
-See ``agents/roadmaps/road-to-product-ui-track.md`` Phase 1 Step 1 for
-the full heuristic table and the ``state.stack`` schema slice it feeds.
-"""
-from __future__ import annotations
-
-from . import detect
-
-__all__ = ["detect"]

package/dist/agent-src/templates/scripts/work_engine/stack/detect.py

@@ -1,187 +0,0 @@
-"""Frontend-stack detection from project manifests.
-
-The detector reads ``composer.json`` and ``package.json`` from a project
-root, applies the heuristic table below in priority order, and returns a
-:class:`StackResult` carrying the labelled frontend plus the manifest
-``mtime`` it was computed against. The dispatcher caches the result on
-``state.stack`` and re-runs detection whenever the recorded ``mtime``
-no longer matches what the filesystem reports.
-
-Heuristics (priority order — first match wins):
-
-1. ``composer.json`` lists ``livewire/livewire`` AND ``livewire/flux`` →
-   ``blade-livewire-flux``
-2. ``package.json`` lists ``react`` AND any of ``@radix-ui/*``,
-   ``shadcn-ui`` or has a ``components.json`` (the shadcn marker file)
-   → ``react-shadcn``
-3. ``package.json`` lists ``vue`` (any major) → ``vue``
-4. Otherwise → ``plain``
-
-Detection is filesystem-cheap: at most three small JSON reads per
-project root. Errors (missing file, malformed JSON, missing ``require``
-section) downgrade to ``plain`` rather than raising — a wrong stack
-label is recoverable (audit catches it, user can override), but a
-crash mid-dispatch is not.
-"""
-from __future__ import annotations
-
-import json
-from dataclasses import dataclass
-from pathlib import Path
-
-KNOWN_STACKS: frozenset[str] = frozenset(
-    {"blade-livewire-flux", "react-shadcn", "vue", "plain"},
-)
-"""All stack labels the detector can return.
-
-Kept as a frozenset so consumers (state schema, fixtures, tests) can
-validate against a single source of truth without re-deriving."""
-
-DEFAULT_STACK = "plain"
-"""Fallback when no manifest signal matches."""
-
-_SHADCN_RADIX_PREFIX = "@radix-ui/"
-_SHADCN_PACKAGE_NAMES: frozenset[str] = frozenset({"shadcn-ui", "shadcn"})
-_FLUX_PACKAGE = "livewire/flux"
-_LIVEWIRE_PACKAGE = "livewire/livewire"
-
-
-@dataclass(frozen=True)
-class StackResult:
-    """Outcome of one detection pass.
-
-    ``mtime`` is the latest mtime among the manifests actually consulted
-    (``composer.json`` and ``package.json``), in POSIX seconds. Callers
-    cache the result keyed on this value; a stale cache is invalidated
-    by the next dispatch when the recorded mtime is older than what
-    :func:`latest_manifest_mtime` returns.
-    """
-
-    frontend: str
-    mtime: float
-
-
-def detect_stack(project_root: Path) -> StackResult:
-    """Inspect ``project_root`` and label the frontend stack.
-
-    Parameters
-    ----------
-    project_root:
-        Directory that should contain a ``composer.json`` or
-        ``package.json`` at its top level. Other layouts (monorepos,
-        nested workspaces) call this with the workspace root that
-        carries the manifest you care about — the caller picks the
-        scope, the detector does not walk upwards.
-
-    Returns
-    -------
-    StackResult
-        ``frontend`` is one of :data:`KNOWN_STACKS`; ``mtime`` is the
-        latest manifest mtime among the files actually consulted, or
-        ``0.0`` when no manifests exist (greenfield project).
-    """
-    composer = _read_json(project_root / "composer.json")
-    package = _read_json(project_root / "package.json")
-    components_json = (project_root / "components.json").is_file()
-    mtime = latest_manifest_mtime(project_root)
-
-    if _is_blade_livewire_flux(composer):
-        return StackResult(frontend="blade-livewire-flux", mtime=mtime)
-
-    if _is_react_shadcn(package, components_json):
-        return StackResult(frontend="react-shadcn", mtime=mtime)
-
-    if _has_vue(package):
-        return StackResult(frontend="vue", mtime=mtime)
-
-    return StackResult(frontend=DEFAULT_STACK, mtime=mtime)
-
-
-def latest_manifest_mtime(project_root: Path) -> float:
-    """Return the latest mtime across the manifests we consult.
-
-    Used by the dispatcher's cache check: when the persisted
-    ``state.stack.mtime`` no longer matches the live value, the cached
-    label is invalidated and detection re-runs. Returns ``0.0`` when no
-    manifest is present so a fresh greenfield repo produces a stable
-    sentinel rather than a missing-file error.
-    """
-    candidates = ("composer.json", "package.json")
-    mtimes = [
-        (project_root / name).stat().st_mtime
-        for name in candidates
-        if (project_root / name).is_file()
-    ]
-    return max(mtimes) if mtimes else 0.0
-
-
-def _read_json(path: Path) -> dict[str, object]:
-    """Read a JSON manifest, returning ``{}`` on any error.
-
-    Wrong-but-recoverable beats crash-mid-dispatch. Audit and the
-    refine step will surface the real shape of the project; the
-    detector's job is just to pick a routing label.
-    """
-    if not path.is_file():
-        return {}
-    try:
-        payload = json.loads(path.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return {}
-    return payload if isinstance(payload, dict) else {}
-
-
-def _all_dependencies(manifest: dict[str, object], *keys: str) -> dict[str, object]:
-    """Merge the dependency-style sections of a manifest into one map.
-
-    composer.json uses ``require`` and ``require-dev``; package.json uses
-    ``dependencies``, ``devDependencies``, ``peerDependencies``, and
-    ``optionalDependencies``. We only care whether a name is present
-    anywhere — version pinning is the audit step's concern.
-    """
-    merged: dict[str, object] = {}
-    for key in keys:
-        section = manifest.get(key)
-        if isinstance(section, dict):
-            merged.update(section)
-    return merged
-
-
-def _is_blade_livewire_flux(composer: dict[str, object]) -> bool:
-    deps = _all_dependencies(composer, "require", "require-dev")
-    return _LIVEWIRE_PACKAGE in deps and _FLUX_PACKAGE in deps
-
-
-def _is_react_shadcn(package: dict[str, object], components_json: bool) -> bool:
-    deps = _all_dependencies(
-        package,
-        "dependencies",
-        "devDependencies",
-        "peerDependencies",
-        "optionalDependencies",
-    )
-    if "react" not in deps:
-        return False
-    has_radix = any(name.startswith(_SHADCN_RADIX_PREFIX) for name in deps)
-    has_shadcn_pkg = any(name in _SHADCN_PACKAGE_NAMES for name in deps)
-    return has_radix or has_shadcn_pkg or components_json
-
-
-def _has_vue(package: dict[str, object]) -> bool:
-    deps = _all_dependencies(
-        package,
-        "dependencies",
-        "devDependencies",
-        "peerDependencies",
-        "optionalDependencies",
-    )
-    return "vue" in deps
-
-
-__all__ = [
-    "DEFAULT_STACK",
-    "KNOWN_STACKS",
-    "StackResult",
-    "detect_stack",
-    "latest_manifest_mtime",
-]