feat(doctor): detect competing memory-care queue writers

Warn when more than one enabled producer can write the same memory-care
scan-latest.json / refresh-queue.json, with a read-only migration plan. This is
diagnostic only: it never disables a cron job, edits a card, or mutates a queue.

- Classify producers by what they write: the Brigade memory-care scan writer
  (`brigade memory care scan`, resolved to memory-care _output_dir) and the
  legacy OpenClaw "Card Decay Scanner (Daily)" cron. Reader scanners
  (import-issues / import memory-refresh) and the "Card Decay Auto-Refresh
  (Safe)" consumer are never counted as writers.
- Compare resolved output directories (expanduser + resolve; reuse
  _scanner_output_path) and emit exactly one WARN per shared directory, naming
  both producers and the migration order.
- Gate the host-global legacy cron producer on the target actually being a
  memory-care workspace, so cron state does not bleed onto unrelated repos.
- Document `.brigade/memory-care/decay/` as the current default write location
  and the legacy `memory/cards/decay/` fallback.

Closes #403

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: solomonneas

docs/memory-care.md

@@ -63,10 +63,12 @@ Safe fix plans are copied into memory-care imports as metadata so the work inbox
 `brigade memory care scan` writes:
 
 ```text
-memory/cards/decay/scan-latest.json
-memory/cards/decay/refresh-queue.json
+.brigade/memory-care/decay/scan-latest.json
+.brigade/memory-care/decay/refresh-queue.json
 ```
 
+Before 0.9.1, scans wrote to `memory/cards/decay/`. Readers still fall back to that location when the default path has no `scan-latest.json` and the legacy path has existing output, so existing workspaces keep their queue continuity.
+
 Queue entries include card identity, issue type, severity, priority, safe summary, evidence references, suggested refresh action, acceptance criteria, source item key, source fingerprint, and safe fix-plan metadata when available. `brigade memory care import-issues` imports those entries as source `memory-care` task imports with dedupe and dismissed-until-changed behavior.
 
 ## Boundary

src/brigade/doctor.py

@@ -5,6 +5,7 @@
 import json
 import os
 import re
+import shlex
 import shutil
 from datetime import date, datetime, timezone
 from pathlib import Path
@@ -80,6 +81,7 @@ def memory_station_checks(ctx: DoctorContext) -> List[CheckResult]:
     checks.extend(_check_memory_cards(ctx.target))
     checks.extend(_check_memory_index(ctx.target))
     checks.extend(_check_memory_care(ctx.target))
+    checks.extend(_check_memory_care_producer_collision(ctx.target))
     return checks
 
 
@@ -627,6 +629,104 @@ def _check_memory_care(target: Path) -> List[CheckResult]:
     return results
 
 
+def _is_memory_care_scan_command(command: str) -> bool:
+    """Return True when a scanner command is the Brigade memory-care writer."""
+    try:
+        parts = shlex.split(command.strip())
+    except ValueError:
+        return False
+    return len(parts) >= 4 and parts[:4] == ["brigade", "memory", "care", "scan"]
+
+
+def _check_memory_care_producer_collision(target: Path) -> List[CheckResult]:
+    """Warn when two enabled producers can write the same memory-care artifact.
+
+    This is a read-only migration-planning check. It inspects configured
+    producers, resolves their output destinations, and reports collisions. It
+    never disables a cron job, edits a card, or mutates a queue file.
+    """
+    from . import memory_cmd
+    from .work_cmd.config import _scanner_output_path
+
+    target = target.expanduser().resolve()
+    producer_dirs: dict[Path, set[str]] = {}
+
+    def _add(dir_path: Path, label: str) -> None:
+        producer_dirs.setdefault(dir_path, set()).add(label)
+
+    p1_exists = False
+    config_dir: Path | None = None
+
+    # Brigade memory-care scanner configured for this workspace.
+    if memory_cmd.config_path(target).is_file():
+        p1_exists = True
+        try:
+            config = memory_cmd.load_config(target) or memory_cmd.MemoryCareConfig()
+        except ValueError:
+            config = memory_cmd.MemoryCareConfig()
+        config_dir = memory_cmd._output_dir(target, config).expanduser().resolve()
+        _add(config_dir, "brigade memory-care")
+
+    # Enabled Brigade scanners whose command is the memory-care writer.
+    scanners_path = target / ".brigade" / "scanners.toml"
+    if scanners_path.is_file():
+        try:
+            data = memory_cmd.tomllib.loads(scanners_path.read_text())
+        except (memory_cmd.tomllib.TOMLDecodeError, OSError):
+            data = {}
+        if isinstance(data, dict):
+            for scanner in data.get("scanner", []):
+                if not isinstance(scanner, dict):
+                    continue
+                if not scanner.get("enabled", False):
+                    continue
+                command = scanner.get("command")
+                if not isinstance(command, str) or not _is_memory_care_scan_command(command):
+                    continue
+                p1_exists = True
+                output_path = _scanner_output_path(target, scanner)
+                if output_path is None:
+                    continue
+                scanner_dir = output_path.expanduser().resolve().parent
+                if scanner_dir == config_dir:
+                    # Same producer as the configured writer; do not double-count.
+                    continue
+                _add(scanner_dir, f"brigade memory-care scanner {scanner.get('id', 'unknown')}")
+
+    # Legacy OpenClaw cron producer (only when this target is a memory-care workspace).
+    if p1_exists:
+        jobs_path = Path.home() / ".openclaw" / "cron" / "jobs.json"
+        if jobs_path.is_file():
+            try:
+                data = json.loads(jobs_path.read_text())
+            except (OSError, json.JSONDecodeError):
+                data = {}
+            jobs = data.get("jobs", []) if isinstance(data, dict) else []
+            legacy_job = _find_job(jobs, "Card Decay Scanner (Daily)")
+            if legacy_job is not None and legacy_job.get("enabled", False):
+                legacy_dir = (target / "memory/cards/decay").expanduser().resolve()
+                _add(legacy_dir, "legacy Card Decay Scanner (Daily)")
+
+    results: List[CheckResult] = []
+    for dir_path, labels in sorted(producer_dirs.items()):
+        if len(labels) < 2:
+            continue
+        try:
+            rel = dir_path.relative_to(target)
+        except ValueError:
+            rel = dir_path.name
+        labels_str = ", ".join(sorted(labels))
+        detail = (
+            f"writer collision on `{rel}`: enabled producers are {labels_str}. "
+            "Migration order: (1) verify the Brigade output with `brigade memory care status`; "
+            "(2) point consumers at the Brigade output location; "
+            "(3) disable the legacy 'Card Decay Scanner (Daily)' cron job. "
+            "This check is read-only; no queue files, cards, or cron jobs were changed."
+        )
+        results.append((WARN, "memory-care: producer collision", detail))
+    return results
+
+
 def _check_memory_care_scan_freshness(scan: Path, scan_date: object) -> CheckResult:
     if not scan_date:
         return (WARN, "memory-care: scan freshness", f"scan_date missing in {scan}")

src/brigade/memory_cmd.py

@@ -79,6 +79,19 @@ def _read_output_dir(target: Path, config: MemoryCareConfig) -> Path:
     return output
 
 
+def memory_care_producer_artifacts(target: Path, config: MemoryCareConfig) -> list[tuple[Path, str]]:
+    """Return the absolute artifact paths produced by the Brigade memory-care scanner.
+
+    Uses the write location (`_output_dir`), not the reader fallback, so
+    producer-collision checks compare actual write destinations.
+    """
+    output = _output_dir(target, config)
+    return [
+        (output / "scan-latest.json", "brigade memory-care"),
+        (output / "refresh-queue.json", "brigade memory-care"),
+    ]
+
+
 def _scan_path(target: Path, config: MemoryCareConfig) -> Path:
     return _read_output_dir(target, config) / "scan-latest.json"