# CorpusFetch Method Slice (Zero-Prose Python Stdlib Reference)
# Canonical Residual: https://corpusfetch.com/c/which-invariants-prevent-scoped-retention-memory-apis-from-silently-resurrecting-forgotten-data-across-scope-boundaries.md
# Remnant Warrant:    https://corpusfetch.com/c/which-invariants-prevent-scoped-retention-memory-apis-from-silently-resurrecting-forgotten-data-across-scope-boundaries.warrant.json
# Markdown SHA-256:   06d01a3c7a3d55855532351b4a0da8289600a504ace0d84602adac0b10887e58
# Code AST SHA-256:   50999a67fb6ee9b26390ec479436bea90687b89021b0fc0b36adacd494f104a7
# Verified Classes:   ForgetNotEffectiveError
# Defensive Guards:   3 fail-closed invariants (zero external deps)

class ForgetNotEffectiveError(RuntimeError):
    """Raised when a forget operation leaves the record reachable via any read path."""


def assert_effectively_forgotten(memory_api, record_id, probe_scopes, probe_queries):
    """
    Verify effective forget across scope boundaries and derived artifacts.

    probe_scopes: every scope whose read path could shadow or reference the record.
    probe_queries: representative queries, including ones that exercise summaries
                   and semantic recall, not just exact-key lookups.
    """
    for scope in probe_scopes:
        for query in probe_queries:
            hits = memory_api.read(scope=scope, query=query)
            for hit in hits:
                if hit.record_id == record_id:
                    raise ForgetNotEffectiveError(
                        f"record {record_id!r} still reachable via scope {scope!r} "
                        f"for query {query!r}; forget was logical, not effective"
                    )

    derived = memory_api.read_derived_index(record_id=record_id)
    if derived is not None:
        raise ForgetNotEffectiveError(
            f"record {record_id!r} still present in derived index "
            f"(summary/embedding) after forget; invalidate synchronously"
        )

    return True


def safe_forget(memory_api, record_id, referencing_scopes, probe_queries):
    """
    Forget by record identity, fanning out to every referencing scope,
    then verify effective forget before returning.
    """
    for scope in referencing_scopes:
        memory_api.forget(scope=scope, record_id=record_id)

    memory_api.invalidate_derived(record_id=record_id)

    try:
        assert_effectively_forgotten(
            memory_api,
            record_id=record_id,
            probe_scopes=referencing_scopes,
            probe_queries=probe_queries,
        )
    except ForgetNotEffectiveError:
        # Do not swallow: a failed effective forget is a correctness incident,
        # not a transient error. Surface it to the caller.
        raise

    return {"record_id": record_id, "effective": True}
