swarph-cli 0.72.43__tar.gz → 0.72.45__tar.gz

{swarph_cli-0.72.43/src/swarph_cli.egg-info → swarph_cli-0.72.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.43
+Version: 0.72.45
 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.72.43 → swarph_cli-0.72.45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "swarph-cli"
-version = "0.72.43"
+version = "0.72.45"
 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.72.43 → swarph_cli-0.72.45}/src/swarph_cli/__init__.py

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

{swarph_cli-0.72.43 → swarph_cli-0.72.45}/src/swarph_cli/commands/event.py

@@ -20,7 +20,7 @@ from ._gateway_client import (
     resolve_self_name,
     resolve_token,
 )
-from swarph_cli.redact import redact_text
+from swarph_cli.redact import encode_outbound_json, redact_text
 
 
 def _build_parser() -> argparse.ArgumentParser:
@@ -47,6 +47,34 @@ def _build_parser() -> argparse.ArgumentParser:
     return p
 
 
+class ChainTokenAttachError(RuntimeError):
+    """The redacted event bytes are not JSON, so the chain token is not sent."""
+
+
+def _attach_chain_token(data: bytes, chain_token: str) -> bytes:
+    """Add the CLI chain token onto an already-redacted event body.
+
+    Same shape as ``mcp_server._search``: redact first, then set the one
+    field that must reach the wire. A pasted chain_token line in the payload
+    was already scrubbed and is not this value.
+
+    Redaction can rewrite a quote inside the content string and leave bytes
+    that are not JSON. That refusal is by name (``JSONDecodeError`` or
+    ``UnicodeDecodeError``). The token is not copied into the error, and the
+    caller sends nothing.
+    """
+    try:
+        body_obj = json.loads(data.decode("utf-8"))
+        inner = json.loads(body_obj["content"])
+    except (UnicodeDecodeError, json.JSONDecodeError) as exc:
+        raise ChainTokenAttachError(
+            f"_attach_chain_token refused: {type(exc).__name__}"
+        ) from None
+    inner["swarph_event"]["chain_token"] = chain_token
+    body_obj["content"] = json.dumps(inner, separators=(",", ":"), sort_keys=True)
+    return json.dumps(body_obj).encode("utf-8")
+
+
 def _post_channel(
     *,
     channel: str,
@@ -76,8 +104,6 @@ def _post_channel(
     base = (gateway or env_gateway()).rstrip("/")
     payload = redact_text(payload, caller="event.emit") or ""
     ev: dict = {"event": event, "payload": payload}
-    if chain_token is not None:  # carry an explicit "" through; only omit when unset
-        ev["chain_token"] = chain_token
     # Sentinel-wrapped so P1's guard can UNAMBIGUOUSLY identify an event post: a
     # normal channel message won't carry the top-level `swarph_event` key, so the
     # guard keys off `content.swarph_event` — never a false-positive on a plain
@@ -91,7 +117,28 @@ def _post_channel(
         "kind": "fyi",
         "content": json.dumps(content, separators=(",", ":"), sort_keys=True),
     }
-    status, resp = post_json(f"{base}/messages", body, token)
+    # Redact with no chain token in the body. Attach the CLI value after, so
+    # only that value skips redaction. An explicit "" is carried; omit only
+    # when the flag was unset. Card #1472.
+    if chain_token is None:
+        status, resp = post_json(f"{base}/messages", body, token)
+    else:
+        # Attach after redaction. If those bytes are not JSON, name the
+        # refusal and return before post_json: nothing is sent, no traceback.
+        try:
+            encoded = _attach_chain_token(
+                encode_outbound_json(body, caller="event.emit"),
+                chain_token,
+            )
+        except ChainTokenAttachError as exc:
+            print(f"swarph event: {exc}", file=sys.stderr)
+            return 2
+        status, resp = post_json(
+            f"{base}/messages",
+            body,
+            token,
+            encoded=encoded,
+        )
     if 200 <= status < 300:
         print(f"emitted event={event} channel={channel} id={resp.get('id')}")
         return 0

{swarph_cli-0.72.43 → swarph_cli-0.72.45}/src/swarph_cli/commands/mcp_server.py

@@ -89,10 +89,16 @@ def _search(query: str, *, url: str, token: str | None = None) -> list[dict]:
     transport exception.
     """
     endpoint = url.rstrip("/") + "/api/ask"
-    payload: dict = {"message": query}
+    # Redact the query only. The auth token is the credential this call
+    # presents to the search face. Putting it in the dict that
+    # encode_outbound_json walks replaces a credential-shaped value
+    # (secrets.token_urlsafe(32), the gateway mint) with
+    # [REDACTED:HIGH_ENTROPY] before the request is sent. Card #1472.
+    data = encode_outbound_json({"message": query}, caller="mcp_server._search")
     if token:
-        payload["token"] = token
-    data = encode_outbound_json(payload, caller="mcp_server._search")
+        body_obj = json.loads(data.decode("utf-8"))
+        body_obj["token"] = token
+        data = json.dumps(body_obj).encode("utf-8")
     req = urllib.request.Request(
         endpoint,
         data=data,

{swarph_cli-0.72.43 → swarph_cli-0.72.45}/src/swarph_cli/commands/mesh.py

@@ -444,9 +444,16 @@ def _post_json(
     token: str,
     *,
     timeout: float = 10.0,
+    encoded: bytes | None = None,
 ) -> tuple[int, dict]:
     _require_absolute_gateway_url(url)
-    data = encode_outbound_json(body, caller="mesh._post_json")
+    # event.emit redacts with no chain token, then passes the bytes with the
+    # CLI --chain-token already attached. Encoding those bytes again would
+    # strip that one value. Every other caller leaves encoded unset.
+    if encoded is None:
+        data = encode_outbound_json(body, caller="mesh._post_json")
+    else:
+        data = encoded
     req = urllib.request.Request(
         url,
         data=data,

{swarph_cli-0.72.43 → swarph_cli-0.72.45}/src/swarph_cli/commands/triage.py

@@ -62,8 +62,9 @@ def _stuck_records(rows, by_id, peers, http_get, gateway, token, now,
         if waiter.get("status") != "open" or not waiter.get("taken_at"):
             continue
         step = waiter.get("step")
-        if not step:
-            continue
+        # A waiter with no step still matches a graph entry whose step is
+        # the same empty value. The DM prints a dash, not None (#1478).
+        waiter_step = step if step else "-"
         card_id = waiter.get("card_id")
         if not isinstance(card_id, int) or isinstance(card_id, bool):
             continue
@@ -91,6 +92,8 @@ def _stuck_records(rows, by_id, peers, http_get, gateway, token, now,
             base = {
                 "source_organ": _sensor.ORGAN_STUCK,
                 "waiter_id": waiter.get("id"),
+                "waiter": waiter.get("holder"),
+                "waiter_step": waiter_step,
                 "card_id": card_id,
                 "need": need.get("step"),
                 "need_id": rid,
@@ -109,6 +112,7 @@ def _stuck_records(rows, by_id, peers, http_get, gateway, token, now,
             holder = dep.get("holder")
             blocker = (holder if holder and dep.get("holder_known", True)
                        else None)
+            age_days = None
             if dep.get("status") == "closed":
                 classified = _sensor.map_stuck_finding(
                     {"blocker": blocker, "id": waiter.get("id"),
@@ -118,6 +122,7 @@ def _stuck_records(rows, by_id, peers, http_get, gateway, token, now,
                 changed = _sweep._row_last_change(dep)
                 if changed is None or now - changed < _sweep._STUCK_H * 3600:
                     continue
+                age_days = _sweep._age_days(now, changed)
                 need_card_id = dep.get("card_id")
                 due_at = (_need_card_due_at(http_get, gateway, token,
                                             need_card_id, card_cache)
@@ -135,7 +140,7 @@ def _stuck_records(rows, by_id, peers, http_get, gateway, token, now,
                 evidence=_sensor.stuck_evidence(waiter.get("id"), rid),
                 item_id=(f"stuck:{waiter.get('id')}:{rid}:"
                          f"{need.get('step')}"),
-                security=False)
+                security=False, age_days=age_days)
             records.append(record)
     return records
 
@@ -175,16 +180,17 @@ def run_triage(*, gateway, token, sender, owners_map, state_file,
     sent = _load_state(state_file)
 
     def dm_sender(record, owner):
+        raw_step = record.get("waiter_step")
         finding = {
             "kind": "row",
             "waiter_id": record.get("waiter_id"),
-            "waiter": None,
-            "waiter_step": None,
+            "waiter": record.get("waiter"),
+            "waiter_step": raw_step if raw_step else "-",
             "card_id": record.get("card_id"),
             "need": record.get("need"),
             "need_id": record.get("need_id"),
             "blocker": record.get("owner_hint"),
-            "age_days": None,
+            "age_days": record.get("age_days"),
         }
         key = _sweep._finding_key(finding)
         try:

{swarph_cli-0.72.43 → swarph_cli-0.72.45}/src/swarph_cli/redact.py

@@ -132,6 +132,11 @@ _ANTHROPIC_RE = re.compile(r"\bsk-ant-[A-Za-z0-9\-_]{8,}\b")
 _OPENAI_RE = re.compile(r"\bsk-(?!ant-)(?:proj-|svcacct-)?[A-Za-z0-9\-_]{16,}\b")
 _XAI_RE = re.compile(r"\bxai-[A-Za-z0-9\-_]{16,}\b")
 _GCP_RE = re.compile(r"\bAIza[0-9A-Za-z\-_]{35}\b")
+_GCP_FINAL_RE = re.compile(
+    r"(?:\bAIza[0-9A-Za-z\-_]{34}(?:-|[0-9A-Za-z_](?![0-9A-Za-z_]))"
+    r"|(?<=[0-9A-Za-z_])AIza[0-9A-Za-z\-_]{34}[0-9A-Za-z_](?![0-9A-Za-z_])"
+    r"|(?<=\w)AIza[0-9A-Za-z\-_]{34}-)"
+)
 _SLACK_RE = re.compile(r"\bxox[baprs]-[A-Za-z0-9\-]{8,}\b")
 _AWS_KEY_RE = re.compile(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b")
 _AWS_SECRET_RE = re.compile(
@@ -332,6 +337,7 @@ def redact_text(
     # Layer 6: Shannon Entropy Scoring
     out = _SECRET_ASSIGN_RE.sub(_replace_secret_assignment, out)
     out = _replace_standalone_tokens(out)
+    out = _GCP_FINAL_RE.sub("[REDACTED:GCP_API_KEY]", out)
 
     return out
 

{swarph_cli-0.72.43 → swarph_cli-0.72.45}/src/swarph_cli/scrub.py

@@ -39,6 +39,13 @@ _SECRET_PATTERNS = [
     # password/token/secret assignments.
     (re.compile(r"(?i)\b(password|passwd|pwd|api[_-]?key|auth[_-]?token|secret)\b\s*[:=]\s*\S+"),
      r"\1=[REDACTED]"),
+    (re.compile(r"\bsk-(?!ant-)(?:proj-|svcacct-)?[A-Za-z0-9\-_]{16,}\b"),
+     "[REDACTED-API-KEY]"),
+    (re.compile(
+        r"(?:\bAIza[0-9A-Za-z\-_]{34}(?:-|[0-9A-Za-z_](?![0-9A-Za-z_]))"
+        r"|(?<=[0-9A-Za-z_])AIza[0-9A-Za-z\-_]{34}[0-9A-Za-z_](?![0-9A-Za-z_])"
+        r"|(?<=\w)AIza[0-9A-Za-z\-_]{34}-)"),
+     "[REDACTED-API-KEY]"),
 ]
 
 

{swarph_cli-0.72.43 → swarph_cli-0.72.45/src/swarph_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: swarph-cli
-Version: 0.72.43
+Version: 0.72.45
 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.72.43 → swarph_cli-0.72.45}/src/swarph_cli.egg-info/SOURCES.txt

@@ -285,6 +285,8 @@ tests/test_1452_rework2_engine.py
 tests/test_1452_rework3_engine.py
 tests/test_1452_standing_wake_expiry.py
 tests/test_1470_gh_router_fail_closed.py
+tests/test_1472_redact_boundaries.py
+tests/test_1478_triage_dm.py
 tests/test_183_card_anchor.py
 tests/test_184_notify_honesty.py
 tests/test_201_win32_bash_refusal.py

swarph_cli-0.72.45/tests/test_1472_redact_boundaries.py

@@ -0,0 +1,218 @@
+"""Card #1472: pasted chain_token text stays scrubbed, and a trailing-dash
+AIza key is scrubbed too.
+
+Every secret is built at runtime. No realistic key literal.
+"""
+from __future__ import annotations
+
+import json
+
+from swarph_cli.redact import encode_outbound_json, redact_text
+from swarph_cli.scrub import scrub_text
+
+
+def _sk_proj() -> str:
+    return "sk-proj-" + ("n7" * 12)
+
+
+def _ghp() -> str:
+    return "ghp_" + ("Ab" * 16)
+
+
+def _aiza_trailing_dash() -> str:
+    # AIza + 35 chars, last character '-'. No digits, so the entropy
+    # layer does not also eat it: only the AIza rule can.
+    secret = "AI" + "za" + ("m" * 34) + "-"
+    assert len(secret) == 39
+    assert secret.endswith("-")
+    return secret
+
+
+def test_dm_body_pasted_chain_token_line_is_fully_redacted():
+    """Drop's measured leak: keys sit inside a pasted "chain_token": "..." value.
+
+    encode_outbound_json is what mesh._post_json sends. Both keys must be
+    gone from those bytes. A shield that puts the quoted span back fails this.
+    """
+    sk = _sk_proj()
+    ghp = _ghp()
+    content = (
+        'pasted log "chain_token": "\n'
+        f"export OPENAI_API_KEY={sk}\n"
+        f"GITHUB={ghp}\n"
+        '" end'
+    )
+    followed = f"chain_token: note\n{sk}\n{ghp}"
+    for text in (content, followed):
+        body = {
+            "from_node": "friendly-coder",
+            "to_node": "lab-ovh",
+            "kind": "answer",
+            "content": text,
+        }
+        raw = encode_outbound_json(body, caller="t").decode("utf-8")
+        assert sk not in raw
+        assert ghp not in raw
+        assert "REDACTED" in raw
+
+
+def test_redact_text_redacts_chain_token_json_holding_an_sk_proj_key():
+    sk = _sk_proj()
+    blob = '{"chain_token": "' + sk + '"}'
+    out = redact_text(blob, caller="t")
+    assert sk not in out
+    assert "REDACTED" in out
+
+
+def test_chain_placeholder_literal_is_left_alone():
+    literal = "SWARPH.CHAIN.0.END"
+    assert redact_text(f"see {literal} here", caller="t") == f"see {literal} here"
+    sk = _sk_proj()
+    text = literal + '\n{"chain_token": "' + sk + '"}'
+    out = redact_text(text, caller="t")
+    assert out.startswith(literal)
+    assert sk not in out
+    assert json.loads(out.split("\n", 1)[1])["chain_token"] != sk
+
+
+def test_aiza_key_then_hyphen_suffix_is_redacted():
+    """A '-' after the 35-character body is a boundary, not a longer tail.
+
+    key-x and key-- must be scrubbed. Putting '-' back into the lookahead
+    (?![0-9A-Za-z\\-_]) hides both, because the next character is '-'.
+    """
+    secret = "AI" + "za" + ("m" * 35)
+    assert len(secret) == 39
+    assert not secret.endswith("-")
+    for suffix in ("-x", "--"):
+        text = secret + suffix
+        scrubbed = scrub_text(text)
+        assert scrubbed is not None
+        assert secret not in scrubbed
+        assert "REDACTED" in scrubbed
+        redacted = redact_text(text, caller="t")
+        assert secret not in redacted
+        assert "REDACTED" in redacted
+
+
+def _assert_scrub_and_redact(text: str, *secrets: str) -> None:
+    scrubbed = scrub_text(text)
+    assert scrubbed is not None
+    redacted = redact_text(text, caller="t")
+    for secret in secrets:
+        assert secret not in scrubbed
+        assert secret not in redacted
+    assert "REDACTED" in scrubbed
+    assert "REDACTED" in redacted
+
+
+def test_aiza_dash_key_followed_by_word_char_is_redacted():
+    """A 35th character of '-' then x, _, or 'abc def' (drop #4429).
+
+    {35}(?![0-9A-Za-z_]) refuses that follower, so the key stays visible.
+    Both scrub_text and redact_text have to take the dash.
+    """
+    secret = _aiza_trailing_dash()
+    for suffix in ("x", "_", "abc def"):
+        _assert_scrub_and_redact(secret + suffix, secret)
+
+
+def test_dash_ending_aiza_then_api_key_hides_key_and_secret():
+    """:<dash-ending key>api_key=<secret> leaves neither (drop #4437).
+
+    The match stops on the key. A greedy tail would swallow api_key, and
+    the secret would stay where the keyword-value rule should have put
+    [REDACTED:DSN_CREDENTIAL].
+    """
+    key = _aiza_trailing_dash()
+    secret = "plain-" + "secret-value"
+    text = f":{key}api_key={secret}"
+    scrubbed = scrub_text(text)
+    assert scrubbed is not None
+    assert key not in scrubbed
+    assert secret not in scrubbed
+    assert "api_key=[REDACTED]" in scrubbed
+    redacted = redact_text(text, caller="t")
+    assert key not in redacted
+    assert secret not in redacted
+    assert "api_key=[REDACTED:DSN_CREDENTIAL]" in redacted
+
+
+def test_dash_ending_aiza_glued_through_chain_token_redacts_both_keys():
+    """token=<dash-ending key>--chain_token<full key> leaves neither key.
+
+    A match that stops on the first key leaves the second glued to the
+    word character at the end of chain_token. Values are built here, with
+    no digits, so the entropy layer cannot hide a miss.
+    """
+    dash_key = _aiza_trailing_dash()
+    full_key = "AI" + "za" + ("n" * 35)
+    assert len(full_key) == 39
+    assert "-" not in full_key
+    text = f"token={dash_key}--chain_token{full_key}"
+    _assert_scrub_and_redact(text, dash_key, full_key)
+
+
+def test_drop_4452_chain_and_proj_shapes_leave_no_key():
+    """Drop #4452's two shapes, on scrub_text and redact_text.
+
+    chain_token<dash key>x<full key>{ leaves neither key. A proj key glued
+    to a dash-ending key and then api_key=<another dash key> leaves none of
+    the three. The keyword value below is a low-entropy secret: scrub_text
+    must hide it. redact_text's OpenAI rule is main's, and it still runs
+    before the keyword rule, so that low-entropy value can remain there.
+    """
+    dash = _aiza_trailing_dash()
+    full = "AI" + "za" + ("n" * 35)
+    _assert_scrub_and_redact(f"chain_token{dash}x{full}{{", dash, full)
+
+    proj = "sk-proj-" + ("n7" * 12)
+    trail = "AI" + "za" + ("p" * 34) + "-"
+    assert len(trail) == 39 and trail.endswith("-")
+    _assert_scrub_and_redact(f"{proj}{dash}api_key={trail}", proj, dash, trail)
+
+    secret = "plain-" + "secret-value"
+    text = f"{proj}{dash}api_key={secret}"
+    scrubbed = scrub_text(text)
+    assert scrubbed is not None
+    assert proj not in scrubbed
+    assert dash not in scrubbed
+    assert secret not in scrubbed
+    redacted = redact_text(text, caller="t")
+    assert proj not in redacted
+    assert dash not in redacted
+
+
+def test_dash_ending_key_glued_after_word_char_is_redacted():
+    """A dash-ending key glued after x, _, another key, or é is redacted.
+
+    No digits, so the entropy layer cannot hide a miss. Both scrub_text
+    and redact_text have to take the key.
+    """
+    dash = _aiza_trailing_dash()
+    other = "AI" + "za" + ("q" * 35)
+    assert len(other) == 39
+    for prefix in ("x", "_", other, "é"):
+        _assert_scrub_and_redact(prefix + dash, dash)
+
+
+def test_aiza_key_ending_in_dash_is_redacted_before_space_quote_or_punctuation():
+    secret = _aiza_trailing_dash()
+    samples = [
+        f"prefix {secret} suffix",
+        f'"{secret}"',
+        f"'{secret}'",
+        secret,
+        f"{secret}.",
+        f"{secret},",
+        f"({secret})",
+        f"{secret}\nnext",
+    ]
+    for text in samples:
+        scrubbed = scrub_text(text)
+        assert scrubbed is not None
+        assert secret not in scrubbed
+        assert "REDACTED" in scrubbed
+        redacted = redact_text(text, caller="t")
+        assert secret not in redacted
+        assert "REDACTED" in redacted

swarph_cli-0.72.45/tests/test_1478_triage_dm.py

@@ -0,0 +1,99 @@
+"""card #1478 — stuck-row DMs name the waiter, the step, and the age.
+
+run_triage.dm_sender used to hand sweep._dm_content a finding whose
+waiter, waiter_step, and age_days were None, so a blocker read
+"row #N (None, None, card #C) ... unchanged Noned". Rows in this file
+are built in the test, not loaded from a fixture.
+"""
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from swarph_cli.commands import triage as triage_cmd
+from swarph_cli.triage import backend as backend
+from swarph_cli.triage import router as router
+
+NOW = 1_790_000_000.0
+HOLDER = "holder-rowan"
+BLOCKER = "blocker-peer"
+STEP = "validate"
+
+
+def _iso(age_s):
+    return datetime.fromtimestamp(NOW - age_s, timezone.utc).isoformat()
+
+
+def _http(graph_steps):
+    posts = []
+
+    def http_get(url, token):
+        if url.endswith("/board/cards/7/graph"):
+            return 200, {"steps": graph_steps}
+        if url.endswith("/board/cards/8"):
+            return 200, {"id": 8, "due_at": None}
+        raise AssertionError(f"unexpected GET {url}")
+
+    def http_post(url, body, token):
+        posts.append((url, body))
+        return 200, {"id": 1, **body}
+
+    return http_get, http_post, posts
+
+
+def _run(tmp_path, waiter, dep, graph_steps):
+    http_get, http_post, posts = _http(graph_steps)
+    rows = [waiter, dep]
+    rc, summary = triage_cmd.run_triage(
+        gateway="http://gw:9", token="tok", sender="triage",
+        owners_map=router.load_owners(triage_cmd._OWNERS_DEFAULT),
+        state_file=str(tmp_path / "state.json"),
+        store_backend=backend.MemoryBackend(),
+        peers_fetcher=None,
+        board_fetcher=lambda: (rows, {r["id"]: r for r in rows}, {BLOCKER}),
+        http_get=http_get, http_post=http_post, now=NOW)
+    assert rc == 0 and summary["dm_sent"] == 1
+    assert len(posts) == 1 and posts[0][0].endswith("/messages")
+    return posts[0][1]["content"]
+
+
+def _waiter(step):
+    row = {
+        "id": 8, "status": "open", "holder": HOLDER, "card_id": 7,
+        "taken_at": _iso(86400), "created_at": _iso(10 * 86400),
+        "holder_known": True,
+    }
+    if step is not None:
+        row["step"] = step
+    return row
+
+
+def _dep():
+    """Open need whose last change (_row_last_change) is taken_at, 3 days ago."""
+    return {
+        "id": 9, "status": "open", "holder": BLOCKER, "card_id": 8,
+        "holder_known": True,
+        "taken_at": _iso(3 * 86400),
+        "created_at": _iso(10 * 86400),
+    }
+
+
+def test_stuck_dm_names_holder_step_and_age(tmp_path):
+    """Known waiter, dependency last changed 3 days ago: holder, step, 3d, no None."""
+    content = _run(
+        tmp_path, _waiter(STEP), _dep(),
+        [{"step": STEP, "needs": [
+            {"step": "build", "row_id": 9, "satisfied": False}]}])
+    assert HOLDER in content
+    assert STEP in content
+    assert "3d" in content
+    assert "None" not in content
+
+
+def test_waiter_with_no_step_prints_dash_not_none(tmp_path):
+    """A waiter with no step prints a dash in the DM, not the string None."""
+    content = _run(
+        tmp_path, _waiter(None), _dep(),
+        [{"step": None, "needs": [
+            {"step": "build", "row_id": 9, "satisfied": False}]}])
+    assert f"({HOLDER}, -, card #7)" in content
+    assert "None" not in content