Stale-Layer Detection Dashboard¶

A monitoring surface — instantiates Layer Decay and Expiration Management

A live inventory of every accumulated layer that surfaces the ones whose content has quietly gone out of date — flagging staleness before anyone acts on a layer that no longer reflects reality.

Old layers do more than take up space — some of them mislead, presenting outdated content as if it were current. Stale-Layer Detection Dashboard is the read-only surface that makes both the pile and its rot visible. It does two things no other mechanism here does: it holds a complete, identity-resolved inventory of the layers that exist, and it flags which of them have gone stale — content that no longer matches reality even though it's still live. Its defining feature is that it targets staleness of meaning, not mere age or size: a document untouched for two years may be perfectly current, while one edited last month can be dangerously wrong if the thing it describes has changed underneath it. The dashboard surfaces those candidates so a human or another mechanism can decide what to refresh, retire, or trust.

Example¶

An engineering org keeps hundreds of runbooks and design docs. The Stale-Layer Detection Dashboard lists every one with signals beside it: last edited, last viewed, owner, and — the key column — a staleness flag derived not from age alone but from cross-signals: does the runbook reference a service that was decommissioned? a config value that has since changed? a person who left? A two-year-old "how to fail over the database" runbook lights red because it names a primary that no longer exists; a recently-edited page stays green. During an incident, an engineer checks the dashboard first and sees the failover doc is flagged stale — sparing them from following instructions that would have pointed at a dead host. The dashboard didn't fix or delete anything; it made the rot legible at the moment it mattered.

How it works¶

Its substance is inventory plus staleness inference, presented for decision, not disposal:

Maintain a resolved inventory: one row per layer, de-duplicated and identity-mapped, so the same doc isn't counted three times under three names.
Infer staleness from meaning-signals, not just age — broken references, contradicted facts, a described system that has since changed, owner departed — because content can be fresh-looking and wrong, or old and fine.
Rank and surface the highest-confidence stale candidates rather than dumping the whole list.
Present, never act: the dashboard shows which layers merit refresh or retirement and hands the decision on.

Tuning parameters¶

Staleness signals — which cues feed the flag (broken links, changed dependencies, contradiction against a source of truth, owner status). Richer signals catch subtler rot but cost integration and raise false positives.
Sensitivity threshold — how strong the evidence must be before a layer is flagged. Loose flags everything and trains people to ignore it; tight misses real rot — the usual signal-to-noise dial.
Inventory scope — how much of the estate the dashboard sees. Gaps in coverage are invisible rot; over-broad scope drowns the important in the trivial.
Refresh cadence — how often signals are recomputed, since a stale staleness reading is its own trap.
Grouping / prioritisation — by owner, by blast radius, by access — deciding whose stale layers rise to the top of the queue.

When it helps, and when it misleads¶

Its strength is visibility: it converts an invisible, distributed pile of possibly-wrong material into a ranked, owned worklist, and it catches the specific danger age-based rules miss — the layer that looks fine but has quietly become false. It is the detector that lets every other mechanism act on evidence rather than guesswork.

Its limits are those of any monitor. A dashboard detects; it does not fix, refresh, or delete, so its value evaporates if nothing downstream acts on what it surfaces — a wall of red flags nobody clears is just decoration, and worse, it launders inaction into the appearance of control. Its staleness inference is heuristic: false positives erode trust until people ignore the flags, false negatives leave dangerous layers green. And it is easily gamed into a vanity board — green because the signals are weak, not because the estate is healthy. The discipline is to tune signals against real incidents, wire flags to an owner and an action, and treat a clean board as suspicious until the detection itself is trusted.

How it implements the components¶

Stale-Layer Detection Dashboard realises the detection-and-inventory side of the archetype — making the pile and its rot visible:

layer_inventory_and_identity_map — it holds the resolved, de-duplicated master list of what layers exist and which is which.
stale_context_detector — it infers and flags which layers have gone out of date in meaning, the signal age alone can't provide.

It does not score a layer's value (that's Age-Weighted Value Score) or perform any disposition; detection feeds those mechanisms, and removal is left to the enforcement siblings.

Instantiates: Layer Decay and Expiration Management — the visibility layer the whole lifecycle relies on to know what exists and what has rotted.
Sibling mechanisms: Age-Weighted Value Score · Tombstone or Deletion Marker · Retention Schedule · Cache Eviction Rule · Lifecycle Storage Tiering Policy · Log Rotation and Cleanup Job · Time-to-Live (TTL) Policy · Dependency-Safe Delete Check · Soft-Delete Quarantine Window · Archive-Restore Test

Notes¶

The dashboard's whole worth is downstream action. On its own it changes nothing — it must be wired so each flagged layer reaches an owner and a disposition path (refresh, retire, or trust-with-caveat). A staleness detector that surfaces rot no one clears has merely documented the problem.