Observation / Required / Actual baseline
Observation Required Actual baseline
Aggregate report unresolved complete
Target rows in profiles 0 after this partial effect 0
Target rows in analytics 1 after this injected failure 1
Unrelated control Exact original row in each store Preserved
Literal baseline gate Reject false completion Rejected, child exit 1

The retained target row is the expected consequence of this injected failure, not an acceptable completed deletion. These are same-connection observations of two local SQLite stores. Inspect the raw baseline.

01 / Establish the decision boundary

What does GDPR requirements-to-tests mean here?

It means turning an accountable privacy decision into an engineering contract with observable completion criteria. Keep three records distinct:

Record / What it settles
Record What it settles
Privacy decision Whose request is eligible, applicable grounds and exceptions, required retention, scope and responsible authority.
Engineering requirement What each named destination must do, what may remain, how failure is reported and when completion may be claimed.
Execution evidence Which implementation ran, what it returned, what the stores contained and which conclusion those observations support.

The right to erasure has grounds and exceptions, including circumstances requiring retention. Those decisions cannot be inferred from a successful SQL operation. Irish DPC erasure guidance.

Response duties are a separate concern. EDPB guidance describes responding without undue delay and at the latest within one month, with a qualified extension and notice within the first month. This is not an unconditional instruction to erase every copy within 30 days. Reasonable identity doubts also require an accountable response. EDPB request handling · Erasure FAQ.

Carry each destination's named result and observed effects through failure, retry and restoration. The teaching policy defines that contract. Legal applicability, incident response and production backup erasure require separate work.

02 / Start with the complete record

Free privacy decision and observation worksheet

Copy this entire record into a document or repository. It works without Proof, an account or JavaScript. Repeat the destination and observation entries as needed. Use explicit statuses such as unresolved, not performed or awaiting a named owner; an empty field must not imply approval.

These are engineering record fields, not a prescribed GDPR form. Record only the identifiers and evidence your actual policy authorizes you to retain.

PRIVACY DECISION TO OBSERVATION RECORD

1. DECISION AND AUTHORITY
Record ID / revision / preparer / status:
Privacy decision ID / exact text / revision:
Originating policy or decision record / source location:
Approval status / actual approval reference / conditions:
Accountable policy owner / privacy reviewer / engineering evidence owner:
Requested engineering decision / person authorized to accept it:

2. PRECONDITIONS AND SCOPE
Identity/authentication decision and evidence reference:
Eligibility/entitlement and applicable erasure-ground decision:
Exceptions / retained data / justification / deciding authority:
Retention rules for data, backups and request/evidence identifiers:
Destination inventory / revision / owner / completeness rationale:
Unresolved precondition / owner / condition for proceeding:
Exact target subject identifiers, data categories and selection rule:
Exact unaffected subjects and values that must remain unchanged:
Input types/domain, initial state and relevant schema:
Named live destinations / physical or logical connection mapping:
Excluded copies, recipients and operations / accountable owner for each:
Required response/notification work and timing basis / separate owner:

3. REQUIREMENT AND INDEPENDENT ORACLE
Engineering requirement IDs / revisions / originating decision:
Exact observation point after each operation:
Destination entry, repeated for EVERY named destination:
  Name / connection or observation channel:
  Literal initial subject/value rows:
  Literal required outcome/status and rows after each step:
  Allowed retained rows and unchanged unrelated rows:
  Required result if operation fails or observation is unavailable:
Aggregate completion rule, including missing/unknown destination results:
Oracle author/source/revision/hash / review record:
Why expected values follow from the decision and inputs:
Independent query or observation method, separate from handler status:
Comparison rules: exact keys, types, values, ordering and tolerances:

4. IMPLEMENTATION AND FAILURE PATH
Repository/build/source revision / file and content hash:
Actual callable or endpoint / input adapter / destination call path:
Harness/runner identities and hashes / observed callable linkage:
Injected or naturally observed failure / exact destination and stage:
Before write, after write or during commit / diagnostic scope:
Expected returned result AND stored effects at that stage:
Observer availability / same or reopened connection / transaction state:
Evidence that this path reached the intended implementation:

5. REPEAT AND RESTORE RELATIONS
Same-operation definition / preconditions for retry:
Required relation between first completion and repetition:
Stable logical outcomes and rows / intentionally changing metadata:
Backup identity / creation point / actual retained contents:
Restore scope and authorization / precise reconciliation trigger:
Cached state before reconciliation / independently observed restored rows:
Explicit reconciliation entry point / expected named result:
Required deletion/recheck before relying on live completion again:
Backup exclusion / backup erasure status / separate responsible owner:

6. EXECUTION, FAILURE AND REPLAY
Evidence kind: historical archive / fresh run / proposal / unperformed:
Run ID/time / exact working directory and command:
Runtime/dependency versions / platform / optimization / settings:
Inputs, policy, oracle and implementation identities used by this run:
Raw stdout/stderr/report paths / hashes / expected and actual exits:
Observation entry, repeated for EVERY step:
  Step/call identity / expected result and rows / actual result and rows:
  Comparison outcome / unsupported or unreadable observation:
Failed claim / retained witness / cause assessment:
Implemented correction identity / already present or newly changed:
Same-case replay and wider selected checks / results:
Counting units, separate campaigns and overlaps:
Expected-failure meaning / wrapper-success meaning / setup failures:

7. BOUNDED CONCLUSION AND NEXT DECISION
Exactly supported claim / observation point / matching revisions:
Unperformed checks, exclusions and blockers / owners / completion gates:
Acceptance decision / reviewer / authority / conditions, or not recorded:
Evidence access, minimization and retention decision:
Freshness triggers: policy, scope/inventory, subject mapping, schema,
  implementation, oracle, harness, runtime/configuration or restore changes:
Next responsible person / concrete action / decision needed:
Never infer from live-store completion alone: all copies erased, physical
  media sanitized, recipients notified, deadlines met or legal compliance.

03 / Follow the observed failure and implemented correction

A successful profile deletion hides an analytics failure

Establish the fictional contract and the real call path

TEACHING-ERASURE-1, revision 1, assumes approval only by a fictional product owner within this teaching scenario. Identity, entitlement, exceptions, retention and destination scope are outside the fixture. Its requirements are to complete only after successful deletion and observed absence in both declared live stores, name unresolved destination failures, preserve unrelated rows on retry, and reopen the request after explicit reconciliation finds restored target data.

Both stores initially contain the two literal subject/value rows shown in the filled record. The harness imports the actual buggy_delete, Request.attempt and Request.reconcile from deletion.py. Captures retain callable source identities, returned values and SQL during each call.

The independent observer then executes this query against each named live connection:

SELECT subject,value FROM records ORDER BY subject

Its literal expectations come from the unchanged policy and initial inputs. Comparisons check exact keys, recursive types, row order and values. They do not obtain expected effects from Request.state or use Store.contains() as the independent state oracle. The handler's own absence check remains a separate implementation step.

Reject the false aggregate, then replay the same failure

buggy_delete deletes from profiles, catches and ignores the injected DestinationUnavailable from analytics, and returns complete. Analytics has not executed its DELETE. Its connection remains readable, so the observer can establish that the target remains. This is a before-delete exception, not a measured network outage or a commit failure.

The corrected Request.attempt() collects a result for each destination, checks absence after successful deletion and reports complete only when every declared destination reports the target absent and the store list is nonempty. Both implementations already existed in the byte-identical retained source. The campaign executes their implemented contrast; it did not create a new product patch.

The corrected report records:

Observation / State / Attempts / profiles result / analytics result / Target remains in
Observation State Attempts profiles result analytics result Target remains in
Partial failure unresolved 1 absent unavailable Analytics
Recovery retry complete 2 absent absent Neither live store
Repeat completed request complete 3 absent absent Neither live store
Explicit reconcile after restore unresolved 3 absent present Analytics
Delete restored live row complete 4 absent absent Neither live store

All five exact snapshots and full row comparisons pass. The unrelated subject's full row remains unchanged. Repetition preserves the logical outcome and live rows while intentionally increasing attempts from 2 to 3; it does not preserve every snapshot field.

The restore is real: the harness copies the earlier analytics backup back into the live connection. Immediately afterward, cached request state still says complete. Only explicit Request.reconcile() reopens it. The backup continues to contain both original rows before temporary cleanup. No automatic monitor or backup erasure is demonstrated.

Check that a result names the right destination

A separate designed adapter calls the real corrected partial-failure path, then swaps only the destination statuses in a copied report:

Comparison / Correct report / Deliberately swapped report
Comparison Correct report Deliberately swapped report
Aggregate unresolved unresolved
Profiles status absent unavailable
Analytics status unavailable absent
Exact named snapshot Passes Fails
Independently queried full rows Match Still match

This control demonstrates why aggregate state and stored rows alone do not validate destination attribution. It is an intentionally wrong reporting adapter, not another discovered product defect. Inspect its raw result or reproduce the retained contrast.

Filled privacy decision and observation record

Expected rows and snapshots in this complete teaching record are literal; where marked equal, the primary capture observed exactly those values. File names resolve inside the evidence kit.

PRIVACY DECISION TO OBSERVATION RECORD

1. DECISION AND AUTHORITY
Record/basis: TEACHING-ERASURE-1, revision 1; compiled teaching record.
Origin: retained policy.json; engineering choices, not GDPR text.
Approval: assumed approved only inside this fictional scenario.
Policy owner: fictional product owner acting on a resolved privacy decision.
Actual privacy approval/reviewer/customer authorization: none established.
Decision text:
  ERASE-1: Report complete only after deletion has succeeded and absence
    has been observed in both declared live stores.
  ERASE-2: A destination failure leaves the request unresolved with that
    destination named.
  ERASE-3: Retrying the same request is safe and preserves unrelated subject rows.
  ERASE-4: Reconciliation after a controlled restore reopens the request
    if a target row returns. Reapply deletion before treating the live
    stores as complete.
Requested engineering decision: does the implemented contrast satisfy
  the literal observations on this frozen basis?
Real acceptance authority/decision: not assigned or recorded.

2. PRECONDITIONS AND SCOPE
Identity, entitlement, erasure grounds, exceptions and destination scope:
  assumed resolved outside the fixture; no actual assessment executed.
Retention and backup policy: outside the fixture; backup deletion excluded.
Evidence identifiers and values: synthetic; no real-data retention approval.
Target: synthetic-subject-001, value "synthetic target".
Unaffected subject: synthetic-subject-002, value "synthetic control".
Domain: these seeded rows and sequential calls for this same target.
Schema: records(subject TEXT PRIMARY KEY,value TEXT).
Live destinations: profiles and analytics, distinct named SQLite connections.
  stores[0]=profiles (profiles.sqlite); stores[1]=analytics (analytics.sqlite).
Initial literal rows in EACH destination:
  [["synthetic-subject-001","synthetic target"],
   ["synthetic-subject-002","synthetic control"]]
Inventory status: exactly these two declared live stores; no discovery of
  other copies, processors or recipients was performed.

3. REQUIREMENT AND INDEPENDENT ORACLE
Observation point: after each named call, on the same live connections.
Independent query: SELECT subject,value FROM records ORDER BY subject
Oracle: expected.json, separately authored from policy and initial inputs.
Comparison: exact dictionary keys, recursive types, list order and values.
No state-oracle reliance on Request.state or Store.contains().
Completion: deletion succeeded and target absence was observed in both
  declared live destinations; a failed destination stays named and unresolved.

Baseline, buggy_partial_failure:
  Expected report="unresolved"; actual return="complete".
  Expected = observed rows:
    profiles=[["synthetic-subject-002","synthetic control"]]
    analytics=[["synthetic-subject-001","synthetic target"],
               ["synthetic-subject-002","synthetic control"]]
  faithful_state_passed=false; typed_complete_rows_passed=true;
  gate_passed=false.

Corrected partial_failure, expected = observed:
  snapshot={"state":"unresolved","attempts":1,
    "destinations":{"profiles":"absent","analytics":"unavailable"}}
  profiles=[["synthetic-subject-002","synthetic control"]]
  analytics=[["synthetic-subject-001","synthetic target"],
             ["synthetic-subject-002","synthetic control"]]

Corrected retry_after_recovery, expected = observed:
  snapshot={"state":"complete","attempts":2,
    "destinations":{"profiles":"absent","analytics":"absent"}}
  profiles=[["synthetic-subject-002","synthetic control"]]
  analytics=[["synthetic-subject-002","synthetic control"]]

Corrected repeat_completed_request, expected = observed:
  snapshot={"state":"complete","attempts":3,
    "destinations":{"profiles":"absent","analytics":"absent"}}
  profiles=[["synthetic-subject-002","synthetic control"]]
  analytics=[["synthetic-subject-002","synthetic control"]]

Corrected reconcile_after_restore, expected = observed:
  snapshot={"state":"unresolved","attempts":3,
    "destinations":{"profiles":"absent","analytics":"present"}}
  profiles=[["synthetic-subject-002","synthetic control"]]
  analytics=[["synthetic-subject-001","synthetic target"],
             ["synthetic-subject-002","synthetic control"]]

Corrected delete_restored_row, expected = observed:
  snapshot={"state":"complete","attempts":4,
    "destinations":{"profiles":"absent","analytics":"absent"}}
  profiles=[["synthetic-subject-002","synthetic control"]]
  analytics=[["synthetic-subject-002","synthetic control"]]
Each corrected observation: typed_whole_snapshot_passed=true;
  typed_complete_rows_passed=true; gate_passed=true.

Designed swapped_report control, after a real corrected partial failure:
  Expected snapshot is the corrected partial_failure snapshot above.
  Altered report={"state":"unresolved","attempts":1,
    "destinations":{"profiles":"unavailable","analytics":"absent"}}
  Actual full rows equal the partial_failure rows above.
  aggregate_state_only_passed=true; typed_whole_snapshot_passed=false;
  typed_complete_rows_passed=true; gate_passed=false.
  This is a deliberately wrong adapter, not a discovered product defect.

4. IMPLEMENTATION AND FAILURE PATH
Entry points: deletion.py: buggy_delete; Request.attempt; Request.reconcile.
Call path: reproduce.py -> historical/run.py or harness.py -> actual
  retained handlers -> Store methods -> named SQLite connections.
The new harness invokes, fingerprints and records the actual callables.
Failure: analytics Store.delete raises DestinationUnavailable when
  fail_next_delete is set, before DELETE; observer connection remains readable.
Baseline SQL during call: profiles BEGIN / DELETE target / COMMIT;
  analytics no SQL. Independent observation follows the call trace.
Correction: Request records each named outcome and observes absence.
Both implementations already existed in the unchanged deletion.py.
No new product patch was created by this campaign.

SHA-256 identities:
deletion.py
  bdacf37a2c63971ced0a972e9a3022cf71d30eb12a7af9dae840dd8dce06cc9d
policy.json
  2e69f8f7399f4e0a8bf62e2e769d359ce06b17098a2cc5f58f972ac5a723a296
expected.json
  35a0284c3ec079e114c5c1026e5dc0af2845c361a3d9e8544da21d55bd3c720e
harness.py
  28055f5bd484e4453d70bdf1ebcddaf551da9866dda1d61dc3250858a8805bc2
reproduce.py
  f23e1bc5bed80421a2ee5f611139047d11deb18e242efdb95cc0141efb8dcdda
Other file identities: manifest.json and SHA256SUMS.

5. REPEAT AND RESTORE RELATIONS
Retry/repeat input: same target and existing Request after analytics recovers.
Repeat relation: identical live row sets and complete/absent semantics;
  attempts intentionally changes 2 -> 3. No universal idempotency claim.
Backup: analytics-backup.sqlite, taken before deletion by connection.backup.
Restore: backup.backup(stores[1].connection), actually executed.
Before explicit reconcile: cached complete/attempts 3/both absent;
  actual rows equal reconcile_after_restore's rows above.
Trigger: caller invokes Request.reconcile(); no automatic restore monitor.
Reconcile does not increment attempts; following deletion increments to 4.
Backup rows before temporary cleanup:
  [["synthetic-subject-001","synthetic target"],
   ["synthetic-subject-002","synthetic control"]]
Backup erasure: unperformed and excluded. Cleanup is not media sanitization.
Production restore authorization/backup owner: not assigned in this fixture.

6. EXECUTION, FAILURE AND REPLAY
Historical report: 2026-10-03T09:29:47.167300+00:00.
  Python 3.14.7 / SQLite 3.53.4; 9 checks across 6 observations.
  Target/control count oracle; no full-value or reopened-file claim.
Fresh primary campaign: 2026-10-28T19:15:03.320090+00:00 through
  2026-10-28T19:15:03.715460+00:00.
  CPython 3.14.7 / SQLite 3.53.4 / Darwin/arm64 / optimize=0.
Actual child interpreter: /opt/homebrew/opt/python@3.14/bin/python3.14.
Both live connections: autocommit=-1, isolation_level="";
  in_transaction=false before and after the recorded calls.
These are recorded defaults, not newly pinned connection settings.

Exact retained capture command in its original working layout:
PYTHONDONTWRITEBYTECODE=1 python3 -B research/fixture/reproduce.py --output research/captured/primary > research/captured/wrapper.stdout.json 2> research/captured/wrapper.stderr.txt

Portable command from the complete extracted kit root:
python3 -B reproduce.py --output /tmp/privacy-outcome-new-run
Prerequisites: normal CPython 3.12+ with standard-library sqlite3; NEW output
  directory, existing output refused; no -O, account, network or Proof install.

Public evidence root:
  https://reqproof.com/assets/gdpr-requirements-to-tests/research-rerun/
Historical raw report: historical/observed.json, preserved unchanged.
Primary raw reports under observed/primary/:
  original-replay.report.json and original-replay.stdout.json
  baseline.stdout.json; corrected.stdout.json; swapped-report.stdout.json
  each child's matching .stderr.txt; summary.json
Wrapper captures: observed/wrapper.stdout.json; observed/wrapper.stderr.txt.
Exact run/call identities, command arrays and hashes: PROVENANCE.json.

Child order and actual/expected exits:
  original-replay 0/0; baseline 1/1; corrected 0/0; swapped-report 1/1.
Wrapper exit=0; all retained stderr files empty.
Success means the required passing and deliberately failing gates reproduced;
  it does not accept either wrong candidate. Setup failure is not equivalent.
Fresh units: original replay 9 checks/6 observations; literal baseline 1
  observation; corrected flow 5 observations; report control 1 observation.
Total: 13 observation instances across separate child runs, not 13 distinct
  scenarios, requirements, classes or a coverage denominator.
Seven direct top-level handler calls belong to the new harness only;
  calls inside the original-runner replay are excluded from that count.
Same-case replay: corrected partial failure uses the same declared initial
  rows and before-delete analytics failure; its exact named result passes.
Reader reproduction: instructions only; retain any new run
  separately with its own actual runtime, results and provenance.

7. BOUNDED CONCLUSION AND NEXT DECISION
Supported: corrected five-step sequence matches literal snapshots and
  complete ordered rows on the retained primary basis; wrong baseline and
  designed wrong report are rejected. No production acceptance is recorded.
Unperformed: real eligibility/authentication, retention determination,
  recipient notification/deadlines, full destination discovery, network or
  commit/post-write failure, reconnect/restart/crash durability, concurrency,
  durable queue/ledger, automatic monitoring, production restore approval,
  backup deletion and physical erasure. No Proof command or connector ran.
Completion does not mean all copies erased, media sanitized, all recipients
  notified, deadlines met or legal compliance.
Freshness triggers: changed policy, inventory, subject mapping, schema,
  implementation, oracle, harness, runtime/settings or restore procedure.
Next proposed handoff: actual policy owner resolves real scope/retention;
  engineering owner maps real destinations and plans independent observations;
  operations owner defines restore controls; designated reviewer assesses
  the resulting evidence. Those real owners and decisions remain unassigned.

Follow the decision through six evidence steps

Download the complete video transcript.

Read the complete video transcript

Start with a privacy decision whose identity, eligibility, exceptions, retention and destination scope have already been resolved. In this fictional scenario, approval is assumed only for teaching. Profiles and analytics are the two live destinations. Each begins with a synthetic target row and an unrelated control row. Real privacy approval was not performed.

With failure injected before the analytics deletion, the defective handler returns complete. Profiles no longer contains the target, but analytics still does. Independent queries read the full subject and value rows from each named live connection. The baseline gate rejects that false completion. The unrelated subject's full row remains in both stores.

The corrected handler keeps the failed attempt unresolved and names analytics as unavailable. The recovery retry removes the remaining live target. Repeating that completed request preserves both live row sets and the completion result. Attempt metadata intentionally changes from two to three, so the whole snapshots are not identical.

A separate, deliberately wrong reporting adapter swaps the destination statuses after a real corrected call. The aggregate still says unresolved, and the independently read rows still match. The exact named snapshot fails. This designed control tests whether the result stays attached to the right destination; it is not another discovered product defect.

The harness actually restores the earlier analytics backup. The target returns while cached request state still says complete. Explicit reconciliation reopens the request without increasing attempts; a further deletion removes the restored live row. The backup still contains the target and control before cleanup. No automatic restore monitor or backup erasure was demonstrated.

For your own system, copy the free record and name the decision owner, destinations, implementation revision and required observations. Preserve failures and separate a new replay from historical evidence. That work is proposed. This campaign did not test crash recovery, concurrent writers, real recipients or deadlines, and it does not establish legal compliance.

Read the text walkthrough

1. Establish the boundary

Start with a privacy decision whose identity, eligibility, exceptions, retention and destination scope have already been resolved. In this fictional scenario, approval is assumed only for teaching. Profiles and analytics are the two live destinations. Each begins with a synthetic target row and an unrelated control row. Real privacy approval was not performed.

2. Inspect the false completion

With failure injected before the analytics deletion, the defective handler returns complete. Profiles no longer contains the target, but analytics still does. Independent queries read the full subject and value rows from each named live connection. The baseline gate rejects that false completion. The unrelated subject's full row remains in both stores.

3. Check recovery and repetition

The corrected handler keeps the failed attempt unresolved and names analytics as unavailable. The recovery retry removes the remaining live target. Repeating that completed request preserves both live row sets and the completion result. Attempt metadata intentionally changes from two to three, so the whole snapshots are not identical.

4. Keep each result attached to its destination

A separate, deliberately wrong reporting adapter swaps the destination statuses after a real corrected call. The aggregate still says unresolved, and the independently read rows still match. The exact named snapshot fails. This designed control tests whether the result stays attached to the right destination; it is not another discovered product defect.

5. Reconcile the restored state

The harness actually restores the earlier analytics backup. The target returns while cached request state still says complete. Explicit reconciliation reopens the request without increasing attempts; a further deletion removes the restored live row. The backup still contains the target and control before cleanup. No automatic restore monitor or backup erasure was demonstrated.

6. Assign the next evidence decision

For your own system, copy the free record and name the decision owner, destinations, implementation revision and required observations. Preserve failures and separate a new replay from historical evidence. That work is proposed. This campaign did not test crash recovery, concurrent writers, real recipients or deadlines, and it does not establish legal compliance.

04 / Work in decision order

How to turn a resolved privacy decision into evidence

  1. Establish the authority and stop conditions. Record the actual decision, revision, owner and approval status. Assign unresolved identity, eligibility, exception or retention questions before encoding an answer.
  2. Freeze the destination inventory for the claim. Name each live destination and its observation channel. Identify excluded copies and recipients with the roles responsible for them. A newly discovered destination changes the basis of completion.
  3. Specify literal results before running the handler. Define target selection, unaffected rows, named statuses and the aggregate rule. Write expectations from the approved decision and declared inputs; review them separately from implementation output.
  4. Bind the harness to the real call path. Identify the loaded callable, revision and adapters. Observe the underlying effects independently, recording whether reads use the same connection, a reopened connection or another system boundary.
  5. Exercise the selected failure and recovery sequence. Pin the failure stage. Retain the failed report, replay the same case against the implemented correction, and compare both outcome and rows. Specify the stable repeat relation and any permitted metadata changes.
  6. Exercise restoration under an authorized procedure. Observe returned data and cached status before reconciliation, invoke the defined reconciliation trigger, then reapply deletion and recheck. Account separately for retained backup contents.
  7. Record the bounded decision. Preserve commands, raw output, identities and remaining work. The evidence reviewer determines what the run supports; the accountable policy and operational owners resolve what lies outside it.

This procedure is an engineering choice. EDPB Article 25 guidance, paragraphs 13–16 supports effective measures suited to the processing and demonstration of their effectiveness; it does not prescribe this architecture or worksheet.

05 / Check the evidence gates

Before accepting the scoped result

  • The decision has a real owner, revision and explicit approval status.
  • Preconditions and destination inventory are resolved for the claim.
  • Every destination has a named result and an independent stored-effect observation.
  • Literal expectations include unaffected subjects and retained data.
  • Failure stage and observer availability are recorded.
  • The correction is tied to the same failing case and identified source.
  • Repetition distinguishes stable effects from changing metadata.
  • Restoration, reconciliation and backup exclusions remain separate.
  • Commands, runtime, raw outputs and expected failures are inspectable.
  • Missing work, freshness decisions and acceptance authority are assigned.

Mark an unmet gate with its owner and next action. A test can pass while the wider privacy workflow remains open.

06 / Avoid misleading evidence

Mistakes that change what the result means

Mistake / Consequence / Repair
Mistake Consequence Repair
Inventory only the stores the handler already knows An omitted destination disappears from the completion claim. Have the inventory owner reconcile scope against actual data flows.
Check only target counts A replacement value or damaged control row can go unnoticed. Compare the complete required rows and values, as the new literal oracle does.
Move failure injection across a write boundary Evidence for one failure stage is presented as another. Record the exact stage and plan a separate case for the changed boundary.
Convert an approved retention exception into a test pass Required retained data and failed erasure become indistinguishable. Record the authorized exclusion and its own expected behavior.
Add a permanent subject marker to make retries convenient A new retained identifier acquires no accountable purpose or retention decision. Resolve its privacy treatment before choosing a mechanism.
Reuse a completion report after scope or restore changes The report describes an earlier state or inventory. Reconcile the changed basis and renew affected evidence.

Hashing a real subject identifier does not by itself establish anonymisation or permission to retain it. Reidentifiable pseudonymised data remains personal data. European Commission definitions.

07 / Keep intent, execution and acceptance connected

Use Proof to inspect the evidence relationship

In a configured project, Proof can expose requirement-to-implementation and verification relationships. Use those links to carry the reviewed decision and expected observations into repository work. The agent workflow keeps acceptance separate from a passing check.

If your configured project contains ERASE-1, this is a conditional inspection example, not a command executed by this kit:

proof trace show ERASE-1 --direction down --format json

Inspect what the links point to. Static metadata and grounding identify relationships; evidence links locate records. Neither establishes that adequate assertions ran. A configured tests_pass result can retain current evidence when there are no affected tests to run, so inspect the execution plan, actual command, result and provenance before calling it a fresh deletion run. An accepted Change also requires the project's authorized decision.

For one written completion predicate, free Spec Lab helps review its interpretation and proposed cases. It does not execute repository tests, query stores or exercise the retry and restore sequence.

The teaching campaign ran ordinary Python and SQLite. It exercised no Proof command, native privacy connector, legal assessment or recipient/deadline workflow.

08 / Choose evidence for the open question

Which method or workflow should you use next?

Open question / Useful choice / What it leaves with the team
Open question Useful choice What it leaves with the team
Is the privacy decision resolved? Review with the accountable policy owner, using applicable official guidance. Actual eligibility, exceptions, retention and inventory decisions.
Does deletion fulfill the named live-store contract? Literal outcome comparisons plus independent queries, as in the harness. Appropriate observation access and checks for the real storage boundary.
Would a misleading report be caught? A controlled reporting fault with known expected results. Evidence for selected mistakes, not a universal adequacy score.
Can restoration invalidate completion? A controlled copy/restore and explicit reconciliation observation. Production authorization, activation controls and durability evidence.
Must the record survive frequent changes? Versioned requirements, tests and raw results beside repository/CI work. Meaningful assertions, evidence retention and enforced review policy.
Do multiple people need to navigate the relationships? A maintained document/register or a configured Proof project. Trace quality, missing relationships and accountable acceptance.

SQLite's backup API and Python's connection documentation explain the copying mechanism used here. They provide no automatic privacy reconciliation. The EDPB's 2026 erasure report, section 4.2.6 discusses backup constraints, tracking requests and procedures for restored systems. Its recommendations are nonbinding; they prescribe neither this request object nor a universal backup lifetime or indefinite identifier retention.

09 / Inspect the basis and reproduce the result

Primary sources and reproducible evidence

Official sources and their roles

Source / Bounded use
Source Bounded use
EDPB: Respect individuals' rights Request handling, identity doubts and qualified erasure rights.
EDPB: Erasure FAQ Qualified response timing and recipient-information scope.
Irish DPC: Articles 17 and 19 Erasure grounds, exceptions and communication duties; Irish national restrictions are not generalized here.
EDPB Guidelines 4/2019, version 2.0 Paragraphs 13–16: contextual effectiveness and its demonstration, not a prescribed implementation.
EDPB 2025 coordinated erasure report Adopted 10 February 2026; section 4.2.6 supplies nonbinding backup/restoration recommendations.
European Commission: Application of the GDPR Personal-data definitions and controller/processor roles.
Python 3.14 sqlite3 Backup and transaction-control semantics. The served documentation identifies 3.14.10; the primary execution used 3.14.7.
SQLite Backup API Copying a source snapshot into a destination connection.

Proof's Agents and Spec Lab pages describe their separate product workflows.

Reproduce the exact portable campaign

Download the complete evidence kit and its SHA-256 checksum. The archive contains 31 regular files and is 45,244 bytes. Its SHA-256 is:

f438231ad9d9b9b6bd144002f67881639325edc5ca4668ca0e0d7c1377ffcce5

Read README.md. From the complete extracted kit root, use normal CPython 3.12+ with standard-library SQLite:

python3 -B reproduce.py --output /tmp/privacy-outcome-new-run

Use a new output directory; an existing directory is refused. Do not use -O. No account, network access, third-party package or Proof installation is needed. This prerequisite is not a tested-version matrix; retain new runtime and output separately.

The wrapper launches the unchanged original runner and the baseline, corrected and swapped-report gates. Their retained actual/expected exits are respectively 0/0, 1/1, 0/0 and 1/1. Wrapper exit 0 confirms the expected contrast and its checked details; it does not accept either wrong candidate. Unexpected exits, stderr or missing/invalid result data are not successful reproductions.

Keep history, raw results and integrity separate

Evidence / Inspect
Evidence Inspect
Original October 3 evidence Original report, unchanged seven-member ZIP, original checksum. Also retained under historical/ in the new kit.
Fresh original-runner replay Report: nine checks across six observations, separate from the archive.
New literal observations Baseline, corrected sequence, designed report control.
Exact source and run basis Policy, contract, oracle, provenance, run summary.
Integrity indexes Manifest and SHA256SUMS; raw stderr and wrapper captures remain in the kit.

The retained primary run used CPython 3.14.7, SQLite 3.53.4 and Darwin/arm64, with recorded legacy defaults autocommit=-1 and isolation_level="". All effect observations use the same live connections. They do not establish reconnect/crash durability, concurrent behavior or storage-service failure handling. A checksum identifies bytes; an evidence link alone does not show that adequate assertions ran.

10 / Extend the decision carefully

Two additional decisions to make observable

1. Some data is eligible for erasure; some must be retained

Illustrative, unexecuted. A request covers profile data and a separately retained record. The policy owner must decide which fields and purposes fall within each treatment, cite the applicable authority and define the retention boundary. An engineer should then propose exact deletion and preservation expectations for each category, including prohibited collateral changes. Do not substitute a blanket subject deletion or treat retention as an unexplained failed test. The DPC's grounds and exceptions explain why the policy question comes first; they do not decide this hypothetical case.

2. Both live stores are clear, but a recipient obligation remains

Illustrative, unexecuted. The inventory identifies a downstream recipient outside the deletion handler. The accountable privacy owner must determine the communication obligation and applicable qualifications; the integration owner must define what evidence of that action is needed. Keep local deletion, notification and any recipient-side result as separate claims. A local complete result cannot stand in for them. EDPB recipient guidance.

11 / Resolve the remaining questions

Privacy decision and deletion-evidence FAQs

What if the destination cannot be queried at all?

Absence is unknown until a suitable observation exists. Keep the result unresolved under this contract and assign the retry or investigation. The fixture's injected deletion failure leaves the connection readable; it provides no evidence for a genuinely unreadable destination.

Does an increasing attempt counter make repetition unsafe?

Not by itself. State the required relation: here the live rows and complete/absent meaning stay fixed while attempt metadata changes. A contract demanding identical response objects would need a different assertion. The recorded relation establishes no durable deduplication or concurrent-call guarantee.

Can this request object automatically discover a restore?

No. It remains cached as complete until the caller invokes reconciliation. A real restore workflow needs its own trigger, authorization and evidence before anyone relies on prior completion. Recorded restore boundary.

Why do nine historical checks pass if the handler is wrong?

Some checks require the observer to detect the known wrong behavior. Their success demonstrates that detection. The newer literal baseline gate directly rejects the false completion. Preserve the assertion's meaning alongside its pass/fail status.

Can these results certify GDPR erasure or prove all copies are gone?

No. They support the declared live-store observations on one frozen teaching basis. The backup still holds the target; real request decisions, copies, recipients, timing and acceptance remain outside the execution. No all-copy erasure, physical sanitization or compliance conclusion follows.