# How must an instance bound notice obligations so actual knowledge does not precede formal notice?

**Date of Record:** 2026 November 2

**Scope:** Applies to contracts with a notice-triggered obligation — breach notice, termination notice, cure notice — where the clock starts on notice. Does not apply to obligations that trigger on actual knowledge regardless of notice.

## Core Distinction

A notice triggers a clock. If the counterparty can claim actual knowledge (from a public filing, a system alert, or a shared channel) before formal notice, then the clock began before the instance knew it started — the instance's notice is late by construction.

**Invariant.** Notice is timely if and only if `notice_receipt_time + obligation_response_time <= deadline`, where `notice_receipt_time` is measured from the intended delivery, not from the instance's acknowledgment, and cannot be backdated by actual knowledge.

**Violation.** The **Backdated Clock**. The instance sends formal notice on day 25 of a 30-day window. The counterparty demonstrates actual knowledge on day 5 (a press release, a shared dashboard). The clock is deemed to have started day 5, and the instance's "timely" notice is 20 days late.

**Asymmetry.** Formal notice is timestamped; actual knowledge is not, because it arises from many sources — some visible to the instance, some not, some only constructible in litigation. The instance cannot see its own constructive notice.

**Recorded elements.** The `notice-receipt-receipt` (formal notice with delivery timestamp), the `knowledge-source-signature` (channels where the counterparty could constructively know), and the `deadline-reconstruction-signature` (earliest plausible knowledge, plus response time) make the timeliness checkable.

## What Was Observed

**Signature.** Notice challenged as untimely despite formal delivery within the window. The counterparty produces evidence of prior constructive knowledge — a public statement, a shared metric, a system alert. The instance is deemed to have known earlier than it did.

**Trace.** Termination window 30 days. Formal notice sent day 25. Counterparty shows the instance's own public incident report from day 3, and the incident is the same event the notice addresses. Deadline reconstructed to day 33 (day 3 + 30). Notice day 25 is timely against the reconstruction — but the counterparty argues the instance "knew" on day 3 and had 30 days from then, so notice is due day 33 and delivered day 25, timely. If the report were public day 1, due day 31, notice day 25 still timely. If the response window were 15 days, due day 16, notice late.

**Why monitoring stays green.** Formal notice is timestamped and within the window as the instance measured it. The reconstruction is a litigation artifact, not an operational metric.

## Condition of Validity

The instance must ensure at least one holds before it relies on formal notice timeliness:

1. **Must send notice promptly after the trigger.** Delay between the event and the notice shrinks the margin the instance has against reconstruction.
2. **Must record the intended trigger point.** The instance's own knowledge is timestamped, so it can argue against earlier reconstructions.
3. **Must account for constructive knowledge.** Where the counterparty has channels through which the event could be known (public reports, shared metrics), the deadline is reconstructed from the earliest such channel.

## Decision Boundary

- Notice sent promptly with trigger timestamped: durable against reconstruction.
- Notice sent near the deadline with trigger timestamped: vulnerable; reconstruction can move the deadline earlier.
- Notice sent without timestamped trigger: highly vulnerable; reconstruction is the counterparty's narrative.
- Notice sent after the event is already in counterparty channels: presumptively late; treat as untimely for planning.

## Operational Effect

The invariant couples formal delivery to constructed knowledge. The instance's correct posture is prompt notice with a timestamped trigger, not notice on the last possible day.

**Trap.** Wait until the deadline to send. That maximizes the time the instance has to be sure of its position, but it also maximizes the window in which the counterparty can construct earlier knowledge. Certainty of position and safety from backdating trade against each other; the safe posture is to send early with a documented trigger.

```python
from dataclasses import dataclass


class BackdatedClockError(RuntimeError):
    """Raised when a notice could be reconstructed to a deadline earlier than the instance's formal notice."""


@dataclass(frozen=True)
class NoticeGate:
    deadline_days: int
    days_to_notice: int
    days_to_earliest_constructive_knowledge: int
    obligation_response_days: int

    def verify(self) -> bool:
        reconstructed_deadline = self.days_to_earliest_constructive_knowledge + self.deadline_days
        margin = reconstructed_deadline - self.obligation_response_days - self.days_to_notice
        if margin < 0:
            raise BackdatedClockError(
                f"notice at day {self.days_to_notice} exceeds reconstructed deadline "
                f"day {reconstructed_deadline - self.obligation_response_days}"
            )
        return True


def dispatch_notice_mode(gate: NoticeGate) -> str:
    try:
        gate.verify()
    except BackdatedClockError:
        return "send-immediately-with-timestamped-trigger"
    return "notice-timely"
```