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

{swarph_cli-0.64.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.64.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

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.64.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.64.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.64.0"
+__version__ = "0.65.0"
 
 __all__ = ["__version__"]

{swarph_cli-0.64.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.64.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
 
 

swarph_cli-0.65.0/src/swarph_cli/dreaming/notify.py

@@ -0,0 +1,162 @@
+"""Notify the owning cell when the dreaming finding set changes (#937).
+
+The finding set is disagree + surface_disagreement, keyed file:line:kind, plus
+each organize finding keyed by its category token and, where the line names
+one, the file. A clean status line is not a finding. Organize keys contain
+no digits: counts stay in the DM body, not in the key. State lives at
+<out-parent>/.last-findings.json and is written only after a successful send.
+An unchanged set sends nothing. A missing state file is a first run: send
+the full set once.
+"""
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+
+# "memory-index-check: clean — ..." is a status line. "not clean" is not.
+_CLEAN = re.compile(r"(?:^|:)\s*clean\b", re.IGNORECASE)
+# Longest first so "MISSING INDEX" wins over a shorter prefix.
+_CATEGORY = (
+    "MISSING INDEX",
+    "DUP_TARGET",
+    "LINES",
+    "CUT",
+    "DANGLING",
+    "ORPHANS",
+    "TRUNCATED",
+    "BUDGET",
+    "WARN",
+)
+_FILE = re.compile(r"[\w.-]+\.md\b")
+
+
+class NotifySendError(Exception):
+    """The mesh send failed. Distinct from a findings exit."""
+
+
+def _category(text: str) -> str | None:
+    for name in _CATEGORY:
+        if text.startswith(name + ":") or text.startswith(name + " "):
+            return name
+    return None
+
+
+def organize_keys(lines) -> list[str]:
+    """One key per category header. Member lines are not keys.
+
+    A header that names a file keys ``organize:CATEGORY:file``. Indented
+    children (CUT's lost pointers, ORPHANS' name window, a DUP_TARGET block)
+    stay out of the key, so they cannot attach to the previous category and
+    a count or a member list cannot change the set. Digits that are part of
+    a filename stay. Counts do not.
+    """
+    keys: set[str] = set()
+    for raw in lines or []:
+        original = str(raw)
+        text = original.strip()
+        if not text or _CLEAN.search(text) or text.startswith("memory-index-check:"):
+            continue
+        # A child line is not a finding of its own, and it must not inherit
+        # the category above it.
+        if original.startswith((" ", "\t")) or _FILE.fullmatch(text):
+            continue
+        cat = _category(text)
+        if not cat:
+            continue
+        files = _FILE.findall(text)
+        if files:
+            keys.add(f"organize:{cat}:{files[0]}")
+        else:
+            keys.add(f"organize:{cat}")
+    return sorted(keys)
+
+
+def finding_keys(verdicts, organized) -> list[str]:
+    keys: set[str] = set()
+    for v in verdicts or []:
+        if v.get("verdict") in ("disagree", "surface_disagreement"):
+            keys.add(f"{v.get('file')}:{v.get('line')}:{v.get('kind')}")
+    keys.update(organize_keys((organized or {}).get("findings") or []))
+    return sorted(keys)
+
+
+def _load_previous(path: Path) -> list[str] | None:
+    if not path.exists():
+        return None
+    data = json.loads(path.read_text(encoding="utf-8"))
+    return list(data.get("keys") or [])
+
+
+def _details(organized) -> list[str]:
+    """Original organize lines, counts included. Clean status is not a finding."""
+    out = []
+    for raw in (organized or {}).get("findings") or []:
+        text = str(raw).strip()
+        if text and not _CLEAN.search(text) and not text.startswith("memory-index-check:"):
+            out.append(text)
+    return out
+
+
+def _body(keys: list[str], previous: list[str] | None, details: list[str]) -> str:
+    if previous is None:
+        lines = ["dreaming findings first run", f"counts: {len(keys)}"]
+        lines.extend(keys)
+    else:
+        prev = set(previous)
+        cur = set(keys)
+        new = sorted(cur - prev)
+        cleared = sorted(prev - cur)
+        lines = [
+            "dreaming findings changed",
+            "new: " + (", ".join(new) if new else "(none)"),
+            "cleared: " + (", ".join(cleared) if cleared else "(none)"),
+            f"counts: {len(keys)} was {len(previous)}",
+        ]
+    if details:
+        lines.append("details:")
+        lines.extend(details)
+    return "\n".join(lines)
+
+
+def apply(out: Path, verdicts, organized, cell: str, sender) -> bool:
+    """Send one DM when the set changes. Return True if a DM was sent.
+
+    ``sender(cell, body)`` raises on failure. State is not written then.
+    """
+    out = Path(out)
+    keys = finding_keys(verdicts, organized)
+    state = out.parent / ".last-findings.json"
+    previous = _load_previous(state)
+    if previous is not None and sorted(previous) == keys:
+        return False
+    body = _body(keys, previous, _details(organized))
+    try:
+        sender(cell, body)
+    except NotifySendError:
+        raise
+    except Exception as exc:
+        raise NotifySendError(str(exc)) from exc
+    state.write_text(json.dumps({"keys": keys}, indent=2) + "\n", encoding="utf-8")
+    return True
+
+
+def mesh_sender(cell: str, content: str) -> None:
+    """Same path as ``swarph mesh send``: one status DM, no second transport."""
+    import argparse
+
+    from swarph_cli.commands.mesh import _run_send
+    from swarph_cli.gateway_default import env_gateway
+
+    ns = argparse.Namespace(
+        to=cell,
+        kind="status",
+        content=content,
+        content_file=None,
+        self_name=None,
+        token_file=None,
+        gateway=env_gateway(),
+    )
+    rc = _run_send(ns)
+    if rc != 0:
+        raise NotifySendError(f"mesh send exited {rc}")

{swarph_cli-0.64.0 → swarph_cli-0.65.0}/src/swarph_cli/dreaming/organize.py

@@ -9,6 +9,11 @@ BUDGET = 24985   # BYTES. GC6 -- never len(str).
 # organised anything; it has queued the same breach for tomorrow.
 TARGET = int(BUDGET * 0.94)   # ~1,500 bytes of headroom
 
+# Claude Code loads MEMORY.md at session start and TRUNCATES after line 200
+# (#938). Same headroom rule as bytes: land under the target, not the ceiling.
+LINE_LIMIT = 200   # harness truncation line
+LINE_TARGET = int(LINE_LIMIT * 0.94)  # 188
+
 
 def organize(clone: Path) -> dict:
     import subprocess, sys
@@ -21,17 +26,25 @@ def organize(clone: Path) -> dict:
     idx = clone / "MEMORY.md"
     if not idx.exists():
         return {"findings": findings, "index_bytes_before": 0,
-                "index_bytes_after": 0, "trimmed": []}
-    before = len(idx.read_bytes())
+                "index_bytes_after": 0, "trimmed": [],
+                "index_lines_before": 0, "index_lines_after": 0}
+    raw = idx.read_bytes()
+    before = len(raw)
+    lines = idx.read_text(encoding="utf-8").split("\n")
+    lines_before = len(lines)
     trimmed = []
-    if before > BUDGET:
-        lines = idx.read_text(encoding="utf-8").split("\n")
-        # Trim from the END: the index is roughly oldest-first, and the head
-        # carries the starred entries. ponytail: crude ordering, replace with a
-        # recency/star rank if trims start dropping things that matter.
-        while len("\n".join(lines).encode("utf-8")) > TARGET and lines:
+    # Two independent limits (#938 / droplet plan-review): bytes OR lines may
+    # bind first depending on line length. Trim when either ceiling is breached;
+    # land under BOTH targets.
+    if before > BUDGET or lines_before > LINE_LIMIT:
+        while lines and (
+                len("\n".join(lines).encode("utf-8")) > TARGET
+                or len(lines) > LINE_TARGET):
             trimmed.append(lines.pop())
         idx.write_text("\n".join(lines), encoding="utf-8")
+    after_text = idx.read_text(encoding="utf-8") if idx.exists() else ""
     return {"findings": findings, "index_bytes_before": before,
             "index_bytes_after": len(idx.read_bytes()),
+            "index_lines_before": lines_before,
+            "index_lines_after": len(after_text.split("\n")) if after_text or idx.exists() else 0,
             "trimmed": [t for t in trimmed if t.strip()]}

{swarph_cli-0.64.0 → swarph_cli-0.65.0}/src/swarph_cli/dreaming/report.py

@@ -48,10 +48,27 @@ def render(verdicts, organized, proposals, corpus, clone, enrich_note: str | Non
          "| verdict | n |", "|---|---|"]
     for k in ("disagree", "surface_disagreement", "mention", "unprobeable", "agree"):
         L.append("| %s | %d |" % (k, counts.get(k, 0)))
-    L += ["", "MEMORY.md: %d bytes before, %d bytes after (budget 24985)" % (
-        organized["index_bytes_before"], organized["index_bytes_after"])]
-    if organized["trimmed"]:
+    # Bytes AND lines (#938 / #332): the harness truncates on both; a byte-only
+    # line hid the line-budget findings that organize already collected.
+    lines_before = organized.get("index_lines_before")
+    lines_after = organized.get("index_lines_after")
+    if lines_before is None or lines_after is None:
+        L += ["", "MEMORY.md: %d bytes before, %d bytes after (budget 24985)" % (
+            organized["index_bytes_before"], organized["index_bytes_after"])]
+    else:
+        L += ["", "MEMORY.md: %d bytes / %d lines before, %d bytes / %d lines after "
+              "(budget 24985 bytes, harness line limit 200)" % (
+                  organized["index_bytes_before"], lines_before,
+                  organized["index_bytes_after"], lines_after)]
+    if organized.get("trimmed"):
         L.append("trimmed %d index line(s) to stay under budget" % len(organized["trimmed"]))
+    org_findings = [f for f in (organized.get("findings") or []) if f.strip()]
+    if org_findings:
+        # Verbatim — LINES, CUT, DANGLING, ORPHANS, DUP_TARGET, BUDGET, WARN…
+        # Drop's surface gap (#332): organize collected these and the report
+        # never printed them, so #REACH had nothing to deliver.
+        L += ["", "organize findings (%d):" % len(org_findings)]
+        L.extend(org_findings)
     L += ["", "enrichment proposals (all marked derived, none applied): %d" % len(proposals)]
     if enrich_note:
         L.append(enrich_note)

{swarph_cli-0.64.0 → swarph_cli-0.65.0}/src/swarph_cli/dreaming/verify.py

@@ -202,12 +202,28 @@ def _is_dated_record(context: str, asserted=None) -> bool:
                for ds, de in hits)
 
 
+def _is_superseded(context: str) -> bool:
+    """Same-line SUPERSEDED note: claim is a MENTION, not a live assertion (#938 addendum / #939).
+
+    grep -i supersed over dreaming/ was 0; corrected corpus lines still carried the
+    old address and re-flagged every night. An inline note must silence the probe.
+    """
+    return bool(re.search(r"SUPERSEDED", context or "", re.I))
+
+
 def verify(corpus: Path, manifest: dict) -> list[dict]:
     verdicts = []
     for c in extract_candidates(corpus):
         results = probe(c)
         base = {k: c[k] for k in ("file", "line", "kind", "ref", "asserted", "context")}
         base["source_sha256"] = manifest["files"].get(c["file"], {}).get("sha256")
+        # #938/#939: SUPERSEDED on the claim's line -> mention, never disagreement.
+        if _is_superseded(c.get("context", "")):
+            r = results[0] if results else {}
+            verdicts.append({**base, "observed": r.get("observed"),
+                             "surface": r.get("surface"),
+                             "verdict": "mention", "reason": "superseded"})
+            continue
         # GC4d: board_stage emits surface_disagreement ONLY, never disagree.
         # A card can sit at spec while the work is done; the corpus may be
         # the accurate side. Locked before any compare, including empty probe.

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.64.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

{swarph_cli-0.64.0 → swarph_cli-0.65.0}/src/swarph_cli.egg-info/SOURCES.txt

@@ -181,6 +181,7 @@ tests/test_307_task4_ask_reply.py
 tests/test_312_codegraph_fuzzy_verb.py
 tests/test_319_refusal_exit_codes.py
 tests/test_323_mistral_backend.py
+tests/test_332_report_organize_findings.py
 tests/test_356_query_filters.py
 tests/test_397_gh_identity_router.py
 tests/test_397_router_preflight.py
@@ -211,6 +212,7 @@ tests/test_725_stdio_reconfigure.py
 tests/test_734_dreaming_enrich_degrade.py
 tests/test_740_edit_project.py
 tests/test_762_cards_edit_priority.py
+tests/test_764_enrich_collapse.py
 tests/test_801_confirm_flow_cli.py
 tests/test_802_stage_history.py
 tests/test_825_codegraph_hook_noise.py
@@ -223,6 +225,7 @@ tests/test_872_identity_refuses_not_warns.py
 tests/test_874_source_text.py
 tests/test_888_opencode_data_dir_can_fail.py
 tests/test_937_dreaming_notify.py
+tests/test_938_organize_line_limit.py
 tests/test_add_security_gate.py
 tests/test_artifact_add.py
 tests/test_artifact_hash.py

swarph_cli-0.65.0/tests/test_332_report_organize_findings.py

@@ -0,0 +1,39 @@
+"""#332: dreaming-report.md must surface organize findings + line counts."""
+from __future__ import annotations
+
+from pathlib import Path
+
+from swarph_cli.dreaming.report import render
+
+
+def test_332_report_renders_lines_finding_and_line_counts(tmp_path):
+    """CAN-FAIL: LINES finding in organized['findings'] appears in report text."""
+    corpus = tmp_path / "mem"
+    clone = tmp_path / "clone"
+    corpus.mkdir()
+    clone.mkdir()
+    lines_finding = (
+        "LINES: MEMORY.md is 197 lines (harness truncates after 200; "
+        "target <= 188) — over target by 9"
+    )
+    cut_finding = (
+        "CUT: MEMORY.md 24068 bytes / 197 lines — LINES binds first; "
+        "cut_line=189 (harness drops from here; byte ceiling 24985, line ceiling 200, "
+        "line target 188)"
+    )
+    dangling = "DANGLING: 1 pointer(s) to a file that does not exist"
+    organized = {
+        "index_bytes_before": 24068,
+        "index_bytes_after": 24068,
+        "index_lines_before": 197,
+        "index_lines_after": 197,
+        "trimmed": [],
+        "findings": [cut_finding, "    first lost pointers:", dangling, lines_finding],
+    }
+    text = render([], organized, [], corpus, clone)
+    assert "197 lines" in text
+    assert "24068 bytes" in text
+    assert lines_finding in text, "LINES finding must appear verbatim"
+    assert cut_finding in text
+    assert dangling in text
+    assert "organize findings" in text