Append-only audit trail of windows replaced by the (incoming) adapt_window
node. Each entry is the OLD window dict at the moment of replacement, plus
``replaced_at`` (ISO-8601) and ``replaced_reason`` (e.g.
"expanded:empty_deploy_timeline"). The cap on entries lives in the
adapt_window rule layer (MAX_EXPANSIONS) — the field itself is unbounded
so future rules can record contractions, anchor refinements, etc.

None until the first replacement. Diagnose narratives may cite this in a
future PR to explain "we tried 120m, found no deploys, widened to 240m".

Added in both AgentState (TypedDict) and AgentStateModel (Pydantic) so
the existing drift test in test_agent_state_sync.py stays green.

No node writes to this field yet — wiring lands in commit 4.

Pure decision logic (no LangChain imports — testable in isolation) for
the upcoming adapt_window node. The rule widens state.incident_window
when the GitDeployTimelineTool came back empty for a shared-window
query, so the next investigation iteration looks further back.

Guard chain (rule no-ops unless every guard passes):

  1. state.incident_window is well-formed (IncidentWindow.from_dict).
  2. state.incident_window_history has fewer than MAX_EXPANSIONS (= 2)
     entries — bounded so a pathological loop cannot run away.
  3. STALE-SIGNAL GUARD: the deploy timeline action must be in the most
     recent state.executed_hypotheses[-1].actions. Without this, evidence
     from iteration 1 would re-fire the rule at the end of iteration 2
     even when the tool didn't run again (caught in plan review).
  4. evidence.git_deploy_timeline_window.source == "shared_incident_window".
     caller_explicit / tool_default / unset (== {}) all fall through, so
     a caller's explicit window is NEVER overridden.
  5. evidence.git_deploy_timeline_count == 0.
  6. Expansion would actually widen the window (i.e. not already at
     MAX_LOOKBACK_MINUTES — IncidentWindow.expanded() would return same
     width).

When fired, the rule emits a state delta with the new window plus the
OLD window appended to history with replaced_at + replaced_reason. Tests
inject now_fn for deterministic ISO timestamps.

30 tests covering happy path, every guard short-circuit, the
stale-signal guard specifically, multi-iteration accumulation, the
MAX_EXPANSIONS cap, and defensive shape handling (malformed evidence,
malformed history, malformed executed_hypotheses, immutable state).

The node entry point lands in the next commit; this commit only adds
the pure logic and the constant.

Thin @Traceable wrapper around adapt_incident_window from rules.py.
Mirrors the existing convention: node_X function in node.py, package
__init__.py re-exports the entry point, top-level app.nodes also
re-exports for graph builder convenience.

The node:
  - calls the pure rule with a copy of state (no mutation)
  - returns {} on no-op (LangGraph's "no state change" signal)
  - returns the rule's state delta when an expansion fires
  - logs at INFO + debug_print when an expansion happens so operators
    can audit which run widened the window and why

Tests cover: state delta passthrough, no-op contract, completely empty
state (early pipeline), state immutability, INFO log on fire, no INFO
log on no-op, RunnableConfig kwarg accepted-and-ignored.

The graph wiring lands in the next commit; nothing currently calls this
node, so adding it does not affect any existing investigation.

Wire node_adapt_window into the LangGraph between diagnose and the
loop-back to plan_actions. Terminal routing decisions (opensre_eval,
publish) bypass it entirely — adaptation only runs when the
investigation is continuing.

Topology change:
  before: diagnose --[conditional "investigate"]--> plan_actions
  after:  diagnose --[conditional "investigate"]--> adapt_window
                                                      |
                                                      v
                                                   plan_actions

The string "investigate" returned by route_investigation_loop is
preserved (it means "loop again", not "go to the investigate node");
only the destination node mapping changes. No routing.py change needed.

6 graph-introspection smoke tests assert: node registered, loop edge
present, unconditional adapt_window->plan_actions edge present,
terminal paths bypass adapt_window, no direct diagnose->plan_actions
edge remains (regression guard), pre-loop edges unchanged.