swarph-cli 0.63.0__tar.gz → 0.65.0__tar.gz

{swarph_cli-0.63.0/src/swarph_cli.egg-info → swarph_cli-0.65.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.63.0
+Version: 0.65.0
 Summary: The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`.
 Author: Pierre Samson, Claude Opus
 License: MIT
@@ -292,9 +292,12 @@ Between-sessions memory pass: **VERIFY · ORGANIZE · ENRICH** against a **CLONE
 ```
 $ swarph dreaming run --corpus ~/.claude/projects/.../memory --out /tmp/dreaming-out
 $ swarph dreaming run --corpus <dir> --out <dir> --verify-only
-$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing
+$ swarph dreaming run --corpus <dir> --out <dir> --notify <cell>
+$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing | 4 notify send failed
 ```
 
+`--notify <cell>` (#937) sends one mesh DM to `<cell>` **only when the finding set changes** (new and cleared findings named, with counts); an unchanged set sends nothing. State lives in `.last-findings.json` beside the `--out` dir and advances only after a successful send, so a failed send (exit 4) retries on the next run.
+
 **Scope is single-cell:** your corpus and your local transcripts. This is not the cross-agent multi-transcript dreaming from the Anthropic talk — that needs a shared transcript surface this release does not claim.
 
 #### The AI Router (why a tool, not a hook)

{swarph_cli-0.63.0 → swarph_cli-0.65.0}/README.md

@@ -244,9 +244,12 @@ Between-sessions memory pass: **VERIFY · ORGANIZE · ENRICH** against a **CLONE
 ```
 $ swarph dreaming run --corpus ~/.claude/projects/.../memory --out /tmp/dreaming-out
 $ swarph dreaming run --corpus <dir> --out <dir> --verify-only
-$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing
+$ swarph dreaming run --corpus <dir> --out <dir> --notify <cell>
+$ echo $?   # 0 clean-and-adjudicated | 1 findings | 2 refused | 3 ran-but-adjudicated-nothing | 4 notify send failed
 ```
 
+`--notify <cell>` (#937) sends one mesh DM to `<cell>` **only when the finding set changes** (new and cleared findings named, with counts); an unchanged set sends nothing. State lives in `.last-findings.json` beside the `--out` dir and advances only after a successful send, so a failed send (exit 4) retries on the next run.
+
 **Scope is single-cell:** your corpus and your local transcripts. This is not the cross-agent multi-transcript dreaming from the Anthropic talk — that needs a shared transcript surface this release does not claim.
 
 #### The AI Router (why a tool, not a hook)

{swarph_cli-0.63.0 → swarph_cli-0.65.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.63.0"
+version = "0.65.0"
 description = "The `swarph` binary — a multi-LLM CLI and mesh-gateway client + bundled server (`swarph gateway`): one-shot prompts across providers, interactive `chat`, multi-provider `spawn` (claude/codex/antigravity via a ProviderMembrane with subprocess billing-scrub), `mesh` send/inbox/register, `brain-ask` over the swarph-brain (gbrain) semantic memory, git-backed `assisted_memory`, per-invocation `gh` identity routing, a silent DM-wake hook, session `import`, and a stranded-session `watchdog`."
 readme = "README.md"
 license = { text = "MIT" }

{swarph_cli-0.63.0 → swarph_cli-0.65.0}/src/swarph_cli/__init__.py

@@ -16,6 +16,6 @@ The architecture splits CLI from substrate so:
 
 from __future__ import annotations
 
-__version__ = "0.63.0"
+__version__ = "0.65.0"
 
 __all__ = ["__version__"]

{swarph_cli-0.63.0 → swarph_cli-0.65.0}/src/swarph_cli/commands/codegraph_hook.py

@@ -37,6 +37,10 @@ from swarph_cli.gateway_default import env_gateway
 
 TIMEOUT_S = 6
 MAX_ROWS = 6
+# Probe one past the display cap so audit can tell "exactly 6" from "hit the
+# clamp" (#825 / lab 48145: 90.5% of rows sat on match_count==6 because the
+# query limit WAS the count).
+_PROBE_LIMIT = MAX_ROWS + 1
 
 # Identifier token — used for prompt terms and for the Bash shred skip (no
 # useful symbol-shaped token left after cleaning).
@@ -89,6 +93,12 @@ def extract_raw_and_cleaned(cmd: str) -> Optional[tuple[str, str]]:
         if tok.startswith("-"):
             continue
         raw = tok.strip("'\"")
+        # Prefer the longest identifier STILL VISIBLE in the raw pattern
+        # before the shredding re.sub (#825). `foo_bar.*[0-9]+` must yield
+        # `foo_bar`, not skip-as-shredded or query regex debris.
+        idents = [t for t in _IDENT_TOKEN.findall(raw) if len(t) >= 3]
+        if idents:
+            return (raw, max(idents, key=len))
         cleaned = re.sub(r"[^\w\s.]", " ", raw).strip()
         if not cleaned:
             return None
@@ -308,7 +318,8 @@ def resolve_pending_outcome(self_name: str, subsequent: str,
 
 # ── gateway query ─────────────────────────────────────────────────────────
 
-def query_gateway(term: str, gateway: str, token: str, limit: int = MAX_ROWS) -> dict:
+def query_gateway(term: str, gateway: str, token: str,
+                   limit: int = _PROBE_LIMIT) -> dict:
     if not (gateway or "").strip():
         return {"error": "MESH_GATEWAY_URL is not set and swarph ships no default "
                          "gateway host (#578) — the graph was never asked"}
@@ -411,6 +422,9 @@ def _query_and_emit(self_name: str, gateway: str, term: str, *,
         return
     env = query_gateway(term, gateway, token)
     rows = env.get("results") or [] if "error" not in env else []
+    capped = len(rows) > MAX_ROWS
+    # Audit sees the probe length (MAX_ROWS+1 ⇒ at-least / capped). Display
+    # still truncates via render()'s rows[:MAX_ROWS].
     name_hit = any_symbol_name_contains_term(term, rows) if rows else False
     fid = firing_id or str(uuid.uuid4())
     write_audit(self_name, {
@@ -424,13 +438,22 @@ def _query_and_emit(self_name: str, gateway: str, term: str, *,
         "raw_term": raw_term or term,
         "skipped": False,
         "match_count": len(rows),
+        "match_count_capped": capped,
         "any_name_contains_term": name_hit,
         "error": env.get("error"),
     })
     if trigger == "prompt":
         register_pending_firing(self_name, fid, session_id)
+    # Render only the display window so the prompt is not flooded.
+    if capped and "error" not in env:
+        env = {**env, "results": rows[:MAX_ROWS], "match_count_capped": True}
     text = render(term, env)
     if text:
+        if capped:
+            text = text.rstrip() + (
+                f"\n  (display capped at {MAX_ROWS}; audit match_count="
+                f"{len(rows)} match_count_capped=true)"
+            )
         _emit(text, event_name)
 
 

{swarph_cli-0.63.0 → swarph_cli-0.65.0}/src/swarph_cli/commands/dreaming.py

@@ -67,6 +67,12 @@ def _build_parser() -> argparse.ArgumentParser:
         help="require enrich; refuse (rc=2) if SLM client unavailable (#734)",
     )
     run.add_argument("--verify-only", action="store_true", help="verify only; skip organize/enrich")
+    run.add_argument(
+        "--notify",
+        default=None,
+        metavar="CELL",
+        help="DM CELL when the finding set changes; no DM when it is unchanged (#937)",
+    )
     return p
 
 
@@ -95,4 +101,6 @@ def run_dreaming(argv: list[str] | None = None) -> int:
         forwarded.append("--enrich")
     if args.verify_only:
         forwarded.append("--verify-only")
+    if getattr(args, "notify", None):
+        forwarded.extend(["--notify", args.notify])
     return dreaming_run.main(forwarded)

{swarph_cli-0.63.0 → swarph_cli-0.65.0}/src/swarph_cli/commands/hooks.py

@@ -1005,36 +1005,47 @@ def uninstall_hook(
     return 0
 
 
-def _is_installed(settings: dict, command: str, bundle: HookBundle) -> bool:
-    """True when ALL of ``bundle``'s bindings' commands are present in settings."""
+def _event_binding_present(
+    settings: dict, command: str, binding: HookBinding,
+) -> bool:
+    """True when one specific event/matcher carries our command."""
     hooks = settings.get("hooks")
     if not isinstance(hooks, dict):
         return False
+    event_list = hooks.get(binding.event)
+    if not isinstance(event_list, list):
+        return False
+    _known = _command_variants_for(command)
+    for entry in event_list:
+        if entry.get("matcher", "") != binding.matcher:
+            continue
+        return any(a.get("command") in _known for a in entry.get("hooks", []))
+    return False
+
+
+def binding_coverage(
+    settings: dict, command: str, bundle: HookBundle,
+) -> tuple[list[str], list[str]]:
+    """Return (present_events, missing_events) for ``bundle``'s bindings (#825).
+
+    A PostToolUse-only install of codegraph-on-grep used to report as plain
+    ``available`` (not installed) while still firing 400 times — the steering
+    half unbound and invisible. Coverage makes PARTIAL legible.
+    """
+    present, missing = [], []
     for b in bundle.bindings:
-        event_list = hooks.get(b.event)
-        if not isinstance(event_list, list):
-            return False
-        found = False
-        for entry in event_list:
-            if entry.get("matcher", "") == b.matcher:
-                # #216 review (Copilot, 2nd pass): THE THIRD SITE. Exact
-                # matching here makes a LEGACY backslash binding read as NOT
-                # INSTALLED, so a Windows cell's real, working hooks list as
-                # "unavailable" — the operator is told nothing is installed
-                # while the bindings sit right there in settings.json.
-                # The previous commit said "one helper, BOTH callers". There
-                # were THREE. A rule applied at N-1 sites is the defect this
-                # class keeps producing, and it produced it again inside the
-                # fix for it.
-                _known = _command_variants_for(command)
-                if any(
-                    a.get("command") in _known for a in entry.get("hooks", [])
-                ):
-                    found = True
-                break
-        if not found:
-            return False
-    return True
+        label = b.event if not b.matcher else f"{b.event}:{b.matcher}"
+        if _event_binding_present(settings, command, b):
+            present.append(label)
+        else:
+            missing.append(label)
+    return present, missing
+
+
+def _is_installed(settings: dict, command: str, bundle: HookBundle) -> bool:
+    """True when ALL of ``bundle``'s bindings' commands are present in settings."""
+    present, missing = binding_coverage(settings, command, bundle)
+    return bool(present) and not missing
 
 
 def list_hooks(
@@ -1045,8 +1056,10 @@ def list_hooks(
 ) -> int:
     """List builtin hooks with install status. One greppable line per builtin::
 
-        name  [installed|available]  trust=builtin  — description
+        name  [installed|partial|available]  trust=builtin  — description
 
+    ``partial`` (#825): at least one binding present but not the full set —
+    the lab-ovh codegraph case (PostToolUse only, UserPromptSubmit/Stop absent).
     When installed and the script carries a ``swarph-cli-bundle-version`` stamp
     (#830), a second line reports match / mismatch vs the running package.
     """
@@ -1054,14 +1067,26 @@ def list_hooks(
     hooks_home_p = Path(hooks_home).expanduser()
     for name in sorted(BUILTIN_HOOKS):
         bundle = BUILTIN_HOOKS[name]
-        command = _installed_command(bundle, hooks_home)
-        # Read side of the same ladder: a legacy install reported as "available"
-        # invites the reinstall that produces a DUPLICATE binding.
-        status = ("installed"
-                  if any(_is_installed(settings, c, bundle)
-                         for c in _installed_command_variants(bundle, hooks_home))
-                  else "available")
+        variants = _installed_command_variants(bundle, hooks_home)
+        # Pick the first variant that has ANY binding coverage for reporting.
+        present: list[str] = []
+        missing: list[str] = [b.event for b in bundle.bindings]
+        for c in variants:
+            p, m = binding_coverage(settings, c, bundle)
+            if len(p) > len(present):
+                present, missing = p, m
+        if present and not missing:
+            status = "installed"
+        elif present and missing:
+            status = "partial"
+        else:
+            status = "available"
         out(f"{name}  [{status}]  trust=builtin  — {bundle.description}")
+        if status == "partial":
+            out(f"  bindings present: {', '.join(present) or '(none)'}")
+            out(f"  bindings MISSING: {', '.join(missing)}  "
+                f"— re-run: swarph hooks add {name}  (#825 fleet bind)")
+            continue
         if status != "installed":
             continue
         script = (hooks_home_p / bundle.script_name).expanduser()

{swarph_cli-0.63.0 → swarph_cli-0.65.0}/src/swarph_cli/dreaming/enrich.py

@@ -56,6 +56,72 @@ def _client():
         return OwnedSLMClient()
 
 
+def _manifest_sha(manifest: dict, file_key: str) -> str | None:
+    """Resolve sha256; model may omit .md while the manifest keys include it."""
+    if not file_key:
+        return None
+    candidates = [file_key]
+    if file_key.endswith(".md"):
+        candidates.append(file_key[:-3])
+    else:
+        candidates.append(file_key + ".md")
+    for key in candidates:
+        hit = manifest.get(key) or {}
+        sha = hit.get("sha256")
+        if sha:
+            return sha
+    return None
+
+
+def _norm_key_part(s: str | None) -> str:
+    """Strip + casefold — drop's #333: 'b.md' and 'b.md ' must be one row."""
+    return (s or "").strip().casefold()
+
+
+def _collapse_proposals(proposals: list[dict]) -> list[dict]:
+    """One row per normalised (file, proposed_link); supported_by = distinct sessions (#764/#333).
+
+    Exact-match dedup would discard agreement evidence — N sessions converging
+    on one link is the strongest signal. Collapse and COUNT; keep session ids.
+    supported_by is NEVER the proposal count: one session emitting the same
+    link twice still counts as 1 (#333).
+    """
+    groups: dict[tuple, dict] = {}
+    order: list[tuple] = []
+    for p in proposals:
+        file_raw = (p.get("file") or "").strip()
+        link_raw = (p.get("proposed_link") or "").strip()
+        if not file_raw or not link_raw:
+            continue
+        # Self-link: a file proposing itself is not enrichment (#333).
+        if _norm_key_part(file_raw) == _norm_key_part(link_raw):
+            continue
+        key = (_norm_key_part(file_raw), _norm_key_part(link_raw))
+        if key not in groups:
+            row = {
+                "file": file_raw,
+                "proposed_link": link_raw,
+                "rationale": p.get("rationale", ""),
+                "derived": True,
+                "supported_by": 0,
+                "sessions": [],
+            }
+            if p.get("source_sha256"):
+                row["source_sha256"] = p["source_sha256"]
+            groups[key] = row
+            order.append(key)
+        g = groups[key]
+        sid = p.get("session_id")
+        if sid and sid not in g["sessions"]:
+            g["sessions"].append(sid)
+        g["supported_by"] = len(g["sessions"])
+        if "source_sha256" not in g and p.get("source_sha256"):
+            g["source_sha256"] = p["source_sha256"]
+        if not g.get("rationale") and p.get("rationale"):
+            g["rationale"] = p["rationale"]
+    return [groups[k] for k in order]
+
+
 def enrich(clone: Path, records: list[dict], client=None) -> list[dict]:
     # `generate`, NOT `generate_json`. Both exist on SLMClient (lines 78 and 118,
     # read 2026-09-03). generate_json coerces its result to a DICT: given a JSON
@@ -101,18 +167,22 @@ def enrich(clone: Path, records: list[dict], client=None) -> list[dict]:
         for i in items:
             if not (isinstance(i, dict) and "file" in i and "link" in i):
                 continue
-            proposals.append({
+            row = {
                 "file": i["file"], "proposed_link": i["link"],
                 "rationale": i.get("why", ""), "derived": True,
                 # TWO COORDINATES, per GC2 and R2: source_sha256 says which FILE
                 # the proposal is against; session_id says which CONTEXT it came
                 # from. The hash alone answers only the first, and the talk's
                 # VERSIONING guardrail asks for both.
-                "source_sha256": manifest.get(i["file"], {}).get("sha256"),
                 "session_id": sid,
                 "transcript_range": s["range"],
-            })
-    return proposals
+            }
+            sha = _manifest_sha(manifest, i["file"])
+            if sha:
+                row["source_sha256"] = sha
+            # null source_sha256 is worse than absent (#764) — omit the key.
+            proposals.append(row)
+    return _collapse_proposals(proposals)
 
 
 def _sessions_from(records: list[dict]) -> dict:

{swarph_cli-0.63.0 → swarph_cli-0.65.0}/src/swarph_cli/dreaming/index_check.py

@@ -15,7 +15,7 @@ The index's own header warns "over budget = SILENT partial load (18 lost
 was missing is the only thing that catches it: something that reads the index and
 asks whether it still points at what exists.
 
-FOUR CHECKS, each for a failure that produced real loss:
+FIVE CHECKS, each for a failure that produced real loss:
 
   1. ORPHANS      a memory file no index points at — invisible when gbrain is down
                   and dependent on semantic luck when it is up
@@ -24,6 +24,9 @@ FOUR CHECKS, each for a failure that produced real loss:
   4. BUDGET       MEMORY.md over 24985 BYTES (wc -c, NOT len(str) — ⭐/— are
                   multi-byte, so a character count reads ~600 low and says
                   "under" for a file that is over)
+  5. LINES        MEMORY.md over the harness's 200-line load (#938). Bytes and
+                  lines are independent limits — long lines hit bytes first;
+                  short ones hit lines first (droplet counter-specimen).
 
 Exit 0 = clean, 1 = findings. Read-only; it never edits the index.
 Run: python3 ~/tools/memory-index-check.py [--quiet]
@@ -49,12 +52,53 @@ BUDGET = 24985  # bytes, MEMORY.md only — stated in the file's own header comm
 # Write|Edit|Bash across several cells, and turning a healthy-but-tight file
 # into a non-zero exit would be a fleet change, not a check.
 TARGET = int(BUDGET * 0.94)  # 23485 bytes; the band is TARGET..BUDGET
+# Claude Code truncates MEMORY.md after line 200 at session start (#938).
+LINE_LIMIT = 200
+LINE_TARGET = int(LINE_LIMIT * 0.94)  # 188
 LINK = re.compile(r"\(([A-Za-z0-9_./-]+\.md)\)")
+TITLE_LINK = re.compile(r"\[([^\]]+)\]\(([A-Za-z0-9_./-]+\.md)\)")
 # A line is suspect when it opens a link it never closes. An explicit "…" means
 # the author elided on purpose, which is a different thing from a cut.
 TRUNC = re.compile(r"\([A-Za-z0-9_./-]*$")
 
 
+def cut_point(text: str) -> int:
+    """First 1-based line the harness drops: byte ceiling or line 201, whichever first.
+
+    cut_line = min(first line where cumulative bytes > BUDGET, LINE_LIMIT + 1).
+    Naming that line (and the pointers at/after it) is the finding payload —
+    "600 bytes over" does not say which memories went invisible (#938 droplet).
+    """
+    cum = 0
+    lines = text.split("\n")
+    for n, line in enumerate(lines, 1):
+        if n > LINE_LIMIT:
+            return LINE_LIMIT + 1
+        # recreate file bytes: join with \n except we count each line's UTF-8
+        # plus the newline that follows it (except possibly the last). Mirror
+        # how the file is stored: "\n".join(lines).encode — so newlines between
+        # lines, none after the final line if the file had no trailing \n.
+        piece = line if n == 1 else "\n" + line
+        cum += len(piece.encode("utf-8"))
+        if cum > BUDGET:
+            return n
+    return 0
+
+
+def pointer_titles_at_or_after(text: str, cut_line: int) -> list[str]:
+    """Pointer entries at or after cut_line — the names that go invisible."""
+    out: list[str] = []
+    for n, line in enumerate(text.split("\n"), 1):
+        if n < cut_line:
+            continue
+        m = TITLE_LINK.search(line)
+        if m:
+            out.append("%s -> %s" % (m.group(1), m.group(2)))
+        elif LINK.search(line):
+            out.append(LINK.search(line).group(1))
+    return out
+
+
 def links_in(name: str) -> set[str]:
     p = MEM / name
     return set(LINK.findall(p.read_text(encoding="utf-8"))) if p.exists() else set()
@@ -174,19 +218,72 @@ def main() -> int:
         findings.append(f"DANGLING: {len(dangling)} pointer(s) to a file that does not exist")
         findings += [f"    {d}" for d in dangling[:20]]
 
+    # Duplicate-target pointers under different titles: allowed, but listed (#938).
     mm = MEM / "MEMORY.md"
+    if mm.exists():
+        by_target: dict[str, set[str]] = {}
+        for line in mm.read_text(encoding="utf-8").split("\n"):
+            for title, target in TITLE_LINK.findall(line):
+                by_target.setdefault(target, set()).add(title)
+        dupes = sorted((t, sorted(titles)) for t, titles in by_target.items()
+                       if len(titles) > 1)
+        if dupes:
+            findings.append(
+                "DUP_TARGET: %d file(s) pointed at under different titles (allowed, listed)"
+                % len(dupes))
+            for target, titles in dupes[:20]:
+                findings.append("    %s <- %s" % (target, " | ".join(titles)))
+
     warn = None
     if mm.exists():
+        text = mm.read_text(encoding="utf-8")
         size = len(mm.read_bytes())
-        if BUDGET >= size > TARGET:
+        nlines = len(text.split("\n"))
+        # Bytes keep the WARN band (TARGET..BUDGET, exit 0). Lines do not:
+        # over LINE_TARGET is a FINDING — lab specimen was 197/200 still "clean"
+        # on bytes while 3 more pointers would be cut (#938 accept).
+        if BUDGET >= size > TARGET and nlines <= LINE_TARGET:
             warn = ("WARN: MEMORY.md is %d BYTES — under the %d ceiling but inside the last %d "
                     "bytes of it. Not broken, not fine: %d bytes of headroom, so the next pointer "
                     "line breaches. Trim to <= %d." % (size, BUDGET, BUDGET - TARGET,
                                                        BUDGET - size, TARGET))
-        if size > BUDGET:
+
+        # Over byte ceiling, line ceiling, or line target: name the cut line.
+        over_bytes = size > BUDGET
+        over_lines = nlines > LINE_LIMIT
+        over_line_target = nlines > LINE_TARGET
+        if over_bytes or over_lines or over_line_target:
+            cut = cut_point(text)
+            if not cut and over_line_target:
+                cut = LINE_LIMIT + 1 if nlines > LINE_LIMIT else (LINE_TARGET + 1)
+            # Which limit binds first: byte cut before line 201, else line.
+            if over_bytes and (not over_lines or cut <= LINE_LIMIT):
+                binder = "BYTES"
+            elif over_lines or over_line_target:
+                binder = "LINES"
+            else:
+                binder = "BYTES"
             findings.append(
-                f"BUDGET: MEMORY.md is {size} BYTES, over {BUDGET} by {size - BUDGET} "
-                f"— over budget loads SILENTLY PARTIAL (its own header records 18 lost 2026-08-26)")
+                "CUT: MEMORY.md %d bytes / %d lines — %s binds first; "
+                "cut_line=%d (harness drops from here; byte ceiling %d, line ceiling %d, "
+                "line target %d)"
+                % (size, nlines, binder, cut or LINE_LIMIT + 1, BUDGET, LINE_LIMIT,
+                   LINE_TARGET))
+            dropped = pointer_titles_at_or_after(text, cut or (LINE_LIMIT + 1))
+            if dropped:
+                findings.append("    first lost pointers:")
+                findings += ["    %s" % d for d in dropped[:20]]
+                if len(dropped) > 20:
+                    findings.append("    … and %d more" % (len(dropped) - 20))
+            if over_bytes:
+                findings.append(
+                    f"BUDGET: MEMORY.md is {size} BYTES, over {BUDGET} by {size - BUDGET} "
+                    f"— over budget loads SILENTLY PARTIAL (its own header records 18 lost 2026-08-26)")
+            if over_lines or over_line_target:
+                findings.append(
+                    "LINES: MEMORY.md is %d lines (harness truncates after %d; "
+                    "target <= %d) — over target by %d"
+                    % (nlines, LINE_LIMIT, LINE_TARGET, max(0, nlines - LINE_TARGET)))
 
     if warn:
         print(warn)
@@ -198,8 +295,11 @@ def main() -> int:
         return 1
     if not quiet:
         mmsize = len((MEM / "MEMORY.md").read_bytes()) if mm.exists() else 0
+        mmlines = (len((MEM / "MEMORY.md").read_text(encoding="utf-8").split("\n"))
+                   if mm.exists() else 0)
         print("memory-index-check: clean — %d files, all indexed; MEMORY.md %d/%d bytes "
-              "(target %d)" % (len(files), mmsize, BUDGET, TARGET))
+              "(target %d), %d/%d lines (target %d)"
+              % (len(files), mmsize, BUDGET, TARGET, mmlines, LINE_LIMIT, LINE_TARGET))
     return 0