@event4u/agent-config 6.0.0 → 6.1.0

package/src/scripts/memory_status.py

@@ -1,46 +1,27 @@
 #!/usr/bin/env python3
-"""Detect the agent-memory backend.
+"""File-backed memory status (no external backend).
 
-Single source of truth for whether skills should use the file fallback
-(`scripts/memory_lookup.py`) or route through the optional
-`@event4u/agent-memory` package.
-
-Exit codes / statuses:
-
-  * `absent`        — package not installed or CLI not on PATH
-  * `misconfigured` — installed but `health()` fails within the timeout
-  * `present`       — installed, healthy, usable now
-
-Result is cached per process under `os.environ["AGENT_MEMORY_STATUS"]`
-and (optionally) under `.agent-memory/status.cache` per session.
+The optional `@event4u/agent-memory` package was removed; retrieval
+(`scripts/memory_lookup.py`) and signal-writing (`scripts/memory_signal.py`)
+are entirely file-backed now. `status()` / `health()` report the file
+backend so the v1 retrieval-contract health envelope stays stable for
+consumers (e.g. the MCP `memory_status` tool).
 
 Usage:
     python3 scripts/memory_status.py                 # human-readable line
     python3 scripts/memory_status.py --format json   # stable JSON
-    from scripts.memory_status import status         # Python import
+    python3 scripts/memory_status.py --health        # v1 health envelope
+    from scripts.memory_status import status, health # Python import
 """
 
 from __future__ import annotations
 
 import argparse
 import json
-import os
-import shutil
-import subprocess
 import sys
-import time
 from dataclasses import dataclass, asdict
-from pathlib import Path
-from typing import Literal
 
-Status = Literal["absent", "misconfigured", "present"]
-
-_CLI_CANDIDATES = ("memory", "agent-memory", "agentmem")
-_HEALTH_TIMEOUT_SECONDS = 2.0
-_CACHE_ENV = "AGENT_MEMORY_STATUS"
-_CACHE_FILE = Path(".agent-memory") / "status.cache"
-
-# Retrieval contract version served by the file-backed fallback.
+# Retrieval contract version served by the file-backed backend.
 # Source of truth: internal/schemas/retrieval-v1.schema.json.
 CONTRACT_VERSION = 1
 _FILE_BACKEND_VERSION = "0.0.0-file"
@@ -49,184 +30,24 @@ _FILE_BACKEND_FEATURES = ("file-fallback",)
 
 @dataclass
 class Result:
-    status: Status
-    backend: str            # "file" or "package"
-    reason: str             # short explanation
-    elapsed_ms: int         # time spent probing (0 if cached)
-    cli_path: str = ""      # resolved CLI path, if any
-    # Populated only when status == "present" — sourced from the
-    # `health` CLI envelope so the v1 health() reports real package
-    # capabilities instead of file-fallback placeholders.
-    backend_version: str = ""
-    features: tuple = ()
-
-
-def _find_cli() -> str:
-    for name in _CLI_CANDIDATES:
-        path = shutil.which(name)
-        if path:
-            return path
-    return ""
-
-
-def _parse_health_envelope(stdout: str) -> dict | None:
-    """Extract the v1 health envelope from `memory health` stdout.
-
-    The package emits a single JSON object on stdout (pino structured
-    logs go to stderr). We tolerate older builds that may have leaked
-    log lines into stdout by scanning for the first top-level object
-    that carries ``contract_version``.
-    """
-    text = (stdout or "").strip()
-    if not text:
-        return None
-    try:
-        obj = json.loads(text)
-    except ValueError:
-        obj = None
-    if isinstance(obj, dict) and obj.get("contract_version"):
-        return obj
-    # Fallback: line-by-line scan for an envelope-shaped object — covers
-    # the case where structured logs accidentally share stdout.
-    for line in text.splitlines():
-        line = line.strip()
-        if not line.startswith("{"):
-            continue
-        try:
-            cand = json.loads(line)
-        except ValueError:
-            continue
-        if isinstance(cand, dict) and cand.get("contract_version"):
-            return cand
-    return None
-
-
-def _probe_health(cli_path: str) -> tuple[bool, str, dict | None]:
-    """Returns (healthy, reason, envelope).
-
-    On success ``envelope`` is the parsed v1 health envelope (may still
-    be ``None`` for very old CLIs that don't emit one). On failure it
-    is always ``None``.
-    """
-    try:
-        out = subprocess.run(
-            [cli_path, "health"],
-            capture_output=True, text=True,
-            timeout=_HEALTH_TIMEOUT_SECONDS,
-        )
-    except subprocess.TimeoutExpired:
-        return False, f"health() timed out after {_HEALTH_TIMEOUT_SECONDS}s", None
-    except FileNotFoundError:
-        return False, "CLI vanished between which() and invoke", None
-    if out.returncode != 0:
-        # First line of combined output, capped, for the reason field.
-        msg = (out.stderr or out.stdout or "exit != 0").strip().splitlines()
-        head = msg[0][:120] if msg else "exit != 0"
-        return False, f"health() returned {out.returncode}: {head}", None
-    envelope = _parse_health_envelope(out.stdout)
-    return True, "ok", envelope
-
-
-def _read_cache() -> Result | None:
-    cached = os.environ.get(_CACHE_ENV)
-    if cached:
-        try:
-            data = json.loads(cached)
-            return Result(**data)
-        except (ValueError, TypeError):
-            pass
-    if _CACHE_FILE.is_file():
-        try:
-            data = json.loads(_CACHE_FILE.read_text(encoding="utf-8"))
-            return Result(**data)
-        except (OSError, ValueError, TypeError):
-            pass
-    return None
-
-
-def _write_cache(result: Result) -> None:
-    payload = json.dumps(asdict(result))
-    os.environ[_CACHE_ENV] = payload
-    try:
-        _CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
-        _CACHE_FILE.write_text(payload, encoding="utf-8")
-    except OSError:
-        # Best-effort cache; skills MUST still work without it.
-        pass
+    status: str = "file"     # always "file" — no external backend
+    backend: str = "file"
+    reason: str = "file-backed memory (no external backend)"
+    elapsed_ms: int = 0
 
 
 def status(refresh: bool = False) -> Result:
-    """Return the cached or freshly-probed backend status.
-
-    Always returns in well under ``_HEALTH_TIMEOUT_SECONDS`` seconds on
-    cache hit; bounded by the timeout on cache miss. Never raises —
-    probe failures degrade to ``absent`` / ``misconfigured`` rather than
-    surfacing exceptions.
-    """
-    if not refresh:
-        cached = _read_cache()
-        if cached is not None:
-            cached.elapsed_ms = 0
-            return cached
-    t0 = time.monotonic()
-    cli = _find_cli()
-    if not cli:
-        result = Result("absent", "file",
-                        "agent-memory CLI not on PATH", 0)
-    else:
-        healthy, reason, envelope = _probe_health(cli)
-        elapsed = int((time.monotonic() - t0) * 1000)
-        if healthy:
-            backend_version = ""
-            features: tuple = ()
-            if isinstance(envelope, dict):
-                bv = envelope.get("backend_version")
-                if isinstance(bv, str):
-                    backend_version = bv
-                feats = envelope.get("features")
-                if isinstance(feats, list) and all(
-                    isinstance(f, str) for f in feats
-                ):
-                    features = tuple(feats)
-            result = Result("present", "package", reason, elapsed, cli,
-                            backend_version=backend_version,
-                            features=features)
-        else:
-            result = Result("misconfigured", "file", reason, elapsed, cli)
-    _write_cache(result)
-    return result
+    """Return the (constant) file-backend status. Never raises."""
+    return Result()
 
 
 def health(refresh: bool = False) -> dict:
-    """Return a v1 retrieval-contract health envelope.
-
-    Schema: ``internal/schemas/retrieval-v1.schema.json`` (HealthResponse).
-    Maps the three-state :func:`status` result onto the contract's
-    ``ok | degraded | error`` so consumers can read
-    ``contract_version`` without caring about the file-vs-package split.
-
-    When the package backs the call (``status == "present"``), the
-    envelope reports the package's own ``backend_version`` and
-    ``features`` so consumers can feature-detect against real
-    capabilities. Otherwise the file-fallback markers are returned.
-    """
-    r = status(refresh=refresh)
-    envelope_status = {
-        "present": "ok",
-        "misconfigured": "degraded",
-        "absent": "ok",
-    }[r.status]
-    if r.status == "present" and (r.backend_version or r.features):
-        backend_version = r.backend_version or _FILE_BACKEND_VERSION
-        features = list(r.features) if r.features else list(_FILE_BACKEND_FEATURES)
-    else:
-        backend_version = _FILE_BACKEND_VERSION
-        features = list(_FILE_BACKEND_FEATURES)
+    """Return a v1 retrieval-contract health envelope (file backend)."""
     return {
         "contract_version": CONTRACT_VERSION,
-        "status": envelope_status,
-        "backend_version": backend_version,
-        "features": features,
+        "status": "ok",
+        "backend_version": _FILE_BACKEND_VERSION,
+        "features": list(_FILE_BACKEND_FEATURES),
     }
 
 
@@ -234,22 +55,20 @@ def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__)
     ap.add_argument("--format", choices=["text", "json"], default="text")
     ap.add_argument("--refresh", action="store_true",
-                    help="Bypass the session cache and probe fresh")
+                    help="No-op (kept for back-compat); status is constant")
     ap.add_argument("--health", action="store_true",
                     help="Emit a v1 retrieval-contract health envelope "
-                         "instead of the legacy status line")
+                         "instead of the status line")
     args = ap.parse_args()
     if args.health:
-        print(json.dumps(health(refresh=args.refresh)))
+        print(json.dumps(health()))
         return 0
-    r = status(refresh=args.refresh)
+    r = status()
     if args.format == "json":
         print(json.dumps(asdict(r)))
     else:
-        icon = {"present": "✅", "misconfigured": "⚠️", "absent": "ℹ️"}[r.status]
-        print(f"  {icon}  backend={r.backend}  status={r.status}  "
-              f"elapsed={r.elapsed_ms}ms  reason={r.reason}")
-    # `absent` is a valid operational state, not a failure.
+        print(f"  ℹ️  backend={r.backend}  status={r.status}  "
+              f"reason={r.reason}")
     return 0
 
 

package/src/scripts/mine_session.py

@@ -1,17 +1,21 @@
 #!/usr/bin/env python3
-"""Mine session transcripts for memory signals — Phase-1 single-host.
+"""Mine a session for memory signals — the engine behind `/memory mine`.
 
-Implements the GATHER SIGNAL phase of the `memory-consolidation` skill
-against Claude-Code-format JSONL transcripts. Default behaviour is
-``--preview`` (stdout only). ``--commit-intake`` appends one JSONL line
-per fact to ``agents/memory/intake/<primary-tag>.jsonl`` per the
-agent-memory contract.
+Implements the GATHER SIGNAL phase of the `memory-consolidation` skill.
+The canonical, **cross-host** source is the chat-history JSONL log
+(``agents/runtime/.agent-chat-history``, written by platform hooks for
+every host); the per-host Claude-Code transcript
+(``~/.claude/projects/*.jsonl``) is a fallback when the log is absent.
+
+``--mode``: ``signals`` (default) extracts normalised facts → intake
+preview / ``--commit-intake``; ``proposals`` frames the facts as
+candidate rule/skill learnings (the `/memory mine` command then runs
+``learning-to-rule-or-skill`` on them); ``both`` renders both.
 
 Strict gates: opt-in transcript access (``--confirm-transcript-access``
 required per invocation), ≤ 5 normalised facts per cycle, redaction
 applied to every yielded text. See
-``.agent-src.uncondensed/commands/memory/mine-session.md`` for the
-authored spec.
+``src/domains/meta/memory/mine-session/command.md`` for the authored spec.
 """
 
 from __future__ import annotations
@@ -28,6 +32,7 @@ from typing import Any, Iterable
 
 ROOT = Path(__file__).resolve().parent.parent.parent
 INTAKE_ROOT = Path("agents/memory/intake")
+CHAT_HISTORY_LOG = Path("agents/runtime/.agent-chat-history")
 DEFAULT_WINDOW_DAYS = 14
 MAX_FACTS = 5
 
@@ -84,7 +89,32 @@ def _iter_claude_code_jsonl(path: Path) -> Iterable[dict[str, Any]]:
                 continue
 
 
+def _iter_chat_history(path: Path) -> Iterable[dict[str, Any]]:
+    """Yield body entries from the cross-host chat-history JSONL log.
+
+    Skips the ``{"t": "header"}`` line. Each body entry carries a flat
+    ``text`` field, a ``ts`` timestamp, a ``t`` role (user/agent/tool/
+    phase), and a session tag ``s`` — see ``scripts/chat_history.py``.
+    """
+    with path.open(encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                obj = json.loads(line)
+            except json.JSONDecodeError:
+                continue
+            if isinstance(obj, dict) and obj.get("t") != "header":
+                yield obj
+
+
 def _turn_text(turn: dict[str, Any]) -> str:
+    # Chat-history log entries carry a flat `text` string.
+    flat = turn.get("text")
+    if isinstance(flat, str):
+        return flat
+    # Claude-Code transcript shape: message.content (str or block list).
     msg = turn.get("message") or {}
     content = msg.get("content")
     if isinstance(content, str):
@@ -142,17 +172,23 @@ def _session_id(transcript: Path) -> str:
     return h[:16]
 
 
-def mine(transcript: Path, since: dt.datetime,
-         extra_patterns: list[re.Pattern[str]]) -> list[dict[str, Any]]:
-    """Return up to MAX_FACTS normalised facts (preview shape)."""
-    turns_in_window = [t for t in _iter_claude_code_jsonl(transcript)
+def mine(entries: Iterable[dict[str, Any]], since: dt.datetime,
+         extra_patterns: list[re.Pattern[str]],
+         session_id: str) -> list[dict[str, Any]]:
+    """Return up to MAX_FACTS normalised facts (preview shape).
+
+    ``entries`` is any iterable of turn-shaped dicts (chat-history log
+    body entries or Claude-Code transcript turns). ``session_id`` is the
+    fallback tag when an entry carries no ``s`` field.
+    """
+    turns_in_window = [t for t in entries
                        if _within_window(_turn_ts(t), since)]
     facts: list[dict[str, Any]] = []
-    session_id = _session_id(transcript)
     for turn in turns_in_window:
         text = _turn_text(turn)
         if not text:
             continue
+        sid = turn.get("s") or session_id
         for tag, family in SIGNAL_FAMILIES.items():
             if not family.search(text):
                 continue
@@ -166,7 +202,7 @@ def mine(transcript: Path, since: dt.datetime,
                 "key": _key_of(text),
                 "observation": obs,
                 "source": "agent",
-                "session_id": session_id,
+                "session_id": sid,
                 "tags": [tag],
             })
             break
@@ -207,17 +243,47 @@ def commit_intake(facts: list[dict[str, Any]], intake_root: Path) -> int:
     return written
 
 
-def _resolve_transcript(host: str, override: str | None) -> Path | None:
+def render_proposal_seeds(facts: list[dict[str, Any]],
+                          project: str, window: str) -> str:
+    """Frame mined facts as candidate rule/skill learnings.
+
+    The `/memory mine` command feeds these into `learning-to-rule-or-skill`;
+    this engine only surfaces the seeds — it does not author proposals.
+    """
+    if not facts:
+        return (f"## Proposal seeds — {project} · {window}\n\n"
+                "_No signals matched — nothing to propose._\n")
+    lines = [f"## Proposal seeds — {project} · {window}", "",
+             "Run `learning-to-rule-or-skill` on each durable seed below:",
+             ""]
+    for i, f in enumerate(facts, 1):
+        lines.append(f"{i}. **{f['type']}** · `{f['key']}` — {f['observation']}")
+    return "\n".join(lines) + "\n"
+
+
+def _resolve_source(source: str, host: str,
+                    override: str | None) -> tuple[Path | None, str]:
+    """Return (path, kind). kind ∈ {chat-history, claude-code}.
+
+    Default ``source=auto`` prefers the cross-host chat-history log, then
+    falls back to the per-host Claude-Code transcript.
+    """
     if override:
-        return Path(override)
+        return Path(override), ("claude-code" if host == "claude-code"
+                                else "chat-history")
+    if source in ("auto", "chat-history") and CHAT_HISTORY_LOG.exists():
+        return CHAT_HISTORY_LOG, "chat-history"
+    if source == "chat-history":
+        return None, "chat-history"
+    # claude-code fallback
     if host != "claude-code":
-        return None
+        return None, host
     home = Path(os.path.expanduser("~/.claude/projects"))
     if not home.exists():
-        return None
+        return None, "claude-code"
     candidates = sorted(home.rglob("*.jsonl"),
                         key=lambda p: p.stat().st_mtime, reverse=True)
-    return candidates[0] if candidates else None
+    return (candidates[0] if candidates else None), "claude-code"
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -227,51 +293,62 @@ def main(argv: list[str] | None = None) -> int:
     ap.add_argument("--confirm-transcript-access", action="store_true")
     ap.add_argument("--preview", action="store_true", default=True)
     ap.add_argument("--commit-intake", action="store_true")
+    ap.add_argument("--mode", choices=["signals", "proposals", "both"],
+                    default="signals",
+                    help="signals → intake facts (default); proposals → "
+                         "proposal seeds for learning-to-rule-or-skill; both")
+    ap.add_argument("--source", choices=["auto", "chat-history", "claude-code"],
+                    default="auto",
+                    help="auto (default) prefers the cross-host chat-history "
+                         "log, then the Claude-Code transcript")
     ap.add_argument("--host", default="claude-code")
     ap.add_argument("--transcript", default=None,
-                    help="Override transcript path (testing)")
+                    help="Override source path (testing)")
     ap.add_argument("--intake-root", default=str(INTAKE_ROOT))
     ap.add_argument("--project", default=Path.cwd().name)
     ns = ap.parse_args(argv)
 
-    if ns.commit_intake and not ns.preview:
-        ns.preview = False
-    if ns.commit_intake and ns.preview:
+    if ns.commit_intake:
         ns.preview = False  # commit-intake wins
 
     if not ns.confirm_transcript_access:
-        print("> Mining reads your session transcript files. Re-run with\n"
+        print("> Mining reads your session log / transcript. Re-run with\n"
               "> --confirm-transcript-access to proceed. The flag is "
               "per-invocation\n> and not persisted.")
         return 0
 
-    if ns.host != "claude-code":
-        print(f"> No TranscriptAdapter for host={ns.host}. Phase 1 supports: "
-              "claude-code.\n> Use /memory propose to record signals "
-              "manually.")
-        return 0
-
-    transcript = _resolve_transcript(ns.host, ns.transcript)
-    if transcript is None or not transcript.exists():
-        print("> No transcript found for host=claude-code. "
-              "Use /memory propose.")
+    path, kind = _resolve_source(ns.source, ns.host, ns.transcript)
+    if path is None or not path.exists():
+        print("> No session source found (no chat-history log, no "
+              "Claude-Code transcript). Use /memory propose to record "
+              "signals manually.")
         return 0
 
+    entries = (_iter_chat_history(path) if kind == "chat-history"
+               else _iter_claude_code_jsonl(path))
     since = (dt.datetime.fromisoformat(ns.since)
              .replace(tzinfo=dt.timezone.utc) if ns.since
              else dt.datetime.now(dt.timezone.utc)
              - dt.timedelta(days=DEFAULT_WINDOW_DAYS))
-    facts = mine(transcript, since, extra_patterns=[])
+    facts = mine(entries, since, extra_patterns=[],
+                 session_id=_session_id(path))
     window = f"since {since.date().isoformat()}"
 
-    if not ns.commit_intake:
-        print(render_preview(facts, ns.project, window, ns.host), end="")
+    if ns.commit_intake:
+        written = commit_intake(facts, Path(ns.intake_root))
+        files_touched = len({f["type"] for f in facts})
+        print(f"✅ Appended {written} intake lines across {files_touched} "
+              "files.\n   Next: /memory promote to lift validated lines "
+              "into curated YAML.")
         return 0
 
-    written = commit_intake(facts, Path(ns.intake_root))
-    files_touched = len({f["type"] for f in facts})
-    print(f"✅ Appended {written} intake lines across {files_touched} files.\n"
-          "   Next: /memory promote to lift validated lines into curated YAML.")
+    # Preview mode — render per --mode.
+    out: list[str] = []
+    if ns.mode in ("signals", "both"):
+        out.append(render_preview(facts, ns.project, window, kind))
+    if ns.mode in ("proposals", "both"):
+        out.append(render_proposal_seeds(facts, ns.project, window))
+    print("\n".join(out), end="")
     return 0
 
 

package/src/scripts/pack_dependency_allowlist.json

@@ -27,9 +27,9 @@
       "reason": "no such skill — drop deferred to 6.1"
     },
     {
-      "pack": "meta",
+      "pack": "memory",
       "slug": "chat-history",
-      "reason": "command-routing target (commands/chat-history/*) listed under skills: — move to routes_to: in 6.1"
+      "reason": "command-routing target (commands/chat-history/*) listed under skills: — move to routes_to: in 6.1 (pack migrated meta→memory in ADR-091)"
     },
     {
       "pack": "meta",