Retain Windows signed sync responses across transient clock failures
Rust development slice / linux (push) Failing after 8s

This commit is contained in:
2026-11-16 12:09:52 +01:00
parent 2d5126876f
commit c7a69d9409
7 changed files with 399 additions and 22 deletions
+26
View File
@@ -1577,3 +1577,29 @@ fn original_completion_after_reconnect_unknown_is_recovered_without_reexecuting(
.is_empty()
);
}
#[test]
fn transient_clock_failure_keeps_the_same_signed_reply_for_both_control_commit_phases() {
let mut f=Fixture::new();
let (_offer,_grant,_result)=f.add("accepted",false,None,script());
let mut client=f.client();
let prepared=f.prepare(&mut client);
let decision=f.decision(&prepared,true);
let signed=f.sign(&decision);
let original=prepared.request.encode_to_vec();
f.clock.trusted=false;
assert!(client.apply(&mut f.db,&signed,&f.clock).is_err());
let (count,pending):(u64,String)=f.db.query_row("SELECT (SELECT count(*) FROM reconcile_requests),pending_request FROM reconcile_meta WHERE id=1",[],|r|Ok((r.get(0)?,r.get(1)?))).unwrap();
assert_eq!(count,1);assert_eq!(pending,prepared.request.request_id);
f.clock.trusted=true;
client.apply(&mut f.db,&signed,&f.clock).unwrap();
f.clock.trusted=false;
assert!(client.apply_consumption(&mut f.ledger,&f.clock).is_err());
assert!(!client.can_start(&f.channel,false,&f.clock));
f.clock.trusted=true;
client.apply_consumption(&mut f.ledger,&f.clock).unwrap();
let (count,raw,saved):(u64,Vec<u8>,Vec<u8>)=f.db.query_row("SELECT (SELECT count(*) FROM reconcile_requests),request,response FROM reconcile_requests WHERE id=?1",[&prepared.request.request_id],|r|Ok((r.get(0)?,r.get(1)?,r.get(2)?))).unwrap();
assert_eq!(count,1);assert_eq!(raw,original);assert_eq!(saved,signed.encode_to_vec());
assert_eq!(f.ledger.query_row("SELECT count(*) FROM consumed",[],|r|r.get::<_,u64>(0)).unwrap(),0);
assert!(client.can_start(&f.channel,false,&f.clock));
}
+2 -2
View File
@@ -500,7 +500,7 @@ impl Client {
"HELPER_APPLY_EXPIRED"
);
let Ok(reading) = clock.reading() else {
tokio::time::sleep(Duration::from_millis(250)).await;
tokio::time::sleep(Duration::from_millis(20)).await;
continue;
};
ensure!(
@@ -519,7 +519,7 @@ impl Client {
if error.to_string() != "HELPER_CONTROL_BUSY" && !pipe_busy {
return Err(error);
}
tokio::time::sleep(Duration::from_millis(250)).await;
tokio::time::sleep(Duration::from_millis(20)).await;
}
}
};
+79
View File
@@ -29,6 +29,8 @@ pub struct Observation {
pub clock_failure: &'static str,
pub needs_sync: bool,
pub prepared: bool,
pub deferred_sync: &'static str,
pub deferred_sync_wait_ms: u64,
pub helper_control: &'static str,
pub helper_apply_unconfirmed: bool,
pub signed_gate_present: bool,
@@ -154,3 +156,80 @@ mod tests {
));
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ResponseWindow {
WaitForClock,
WithinWindow,
Expired,
}
/// Only scheduling of an independently authenticated, already bound control
/// reply. It cannot qualify a clock or turn this reply into an authorization.
pub fn response_window(
issued: chrono::DateTime<chrono::Utc>,
until: chrono::DateTime<chrono::Utc>,
held: std::time::Duration,
reading: Option<(chrono::DateTime<chrono::Utc>, chrono::DateTime<chrono::Utc>)>,
) -> ResponseWindow {
if held >= std::time::Duration::from_secs(60) || until <= issued {
return ResponseWindow::Expired;
}
let Some((wall, upper)) = reading else {
return ResponseWindow::WaitForClock;
};
if upper < wall || upper >= until {
return ResponseWindow::Expired;
}
if wall < issued {
return ResponseWindow::WaitForClock;
}
ResponseWindow::WithinWindow
}
#[cfg(test)]
mod response_tests {
use super::*;
#[test]
fn signed_response_waits_for_fresh_clock_and_issued_at_without_extending_its_deadline() {
let issued = chrono::DateTime::from_timestamp(100, 0).unwrap();
let until = issued + chrono::Duration::seconds(30);
let short = std::time::Duration::from_millis(20);
assert_eq!(
response_window(issued, until, short, None),
ResponseWindow::WaitForClock
);
assert_eq!(
response_window(
issued,
until,
short,
Some((
issued - chrono::Duration::milliseconds(500),
issued + chrono::Duration::milliseconds(100)
))
),
ResponseWindow::WaitForClock
);
assert_eq!(
response_window(
issued,
until,
short,
Some((issued, issued + chrono::Duration::milliseconds(100)))
),
ResponseWindow::WithinWindow
);
assert_eq!(
response_window(
issued,
until,
short,
Some((until - chrono::Duration::milliseconds(1), until))
),
ResponseWindow::Expired
);
assert_eq!(
response_window(issued, until, std::time::Duration::from_secs(60), None),
ResponseWindow::Expired
);
}
}
+155 -15
View File
@@ -400,6 +400,19 @@ fn needs_bound_outcome(
}
Ok(true)
}
struct DeferredSync {
generation: u64,
response: SyncResponse,
issued_at: chrono::DateTime<Utc>,
valid_until: chrono::DateTime<Utc>,
received_at: Instant,
applied: Option<reconcile::Applied>,
}
fn clock_temporarily_unavailable(error: &anyhow::Error) -> bool {
error
.chain()
.any(|cause| cause.to_string().starts_with("TIME_"))
}
struct Running {
offer: JobOffer,
grant: ExecutionPermitPayload,
@@ -547,6 +560,7 @@ struct Agent {
time_refresh: Option<TimeRefresh>,
sync: Option<reconcile::ClientSync>,
prepared: bool,
deferred_sync: Option<DeferredSync>,
#[cfg(feature = "system-helper")]
prepared_request: Option<Vec<u8>>,
#[cfg(feature = "system-helper")]
@@ -841,7 +855,7 @@ impl Agent {
}
}
#[cfg(feature = "system-helper")]
async fn drain_helper_apply(&mut self) {
async fn drain_helper_apply(&mut self, until: Instant) {
// Keep the same bounded original worker and independent time lane
// alive until its acknowledgement settles. This never opens a gate,
// confirms a new generation, retries Apply or authorizes an effect.
@@ -851,7 +865,8 @@ impl Agent {
match control {
HelperControl::Apply(_, task) => {
if let Ok(Ok(Ok(_snapshot))) =
tokio::time::timeout(Duration::from_secs(70), task).await
tokio::time::timeout(until.saturating_duration_since(Instant::now()), task)
.await
{
self.helper_apply_unconfirmed = false;
}
@@ -889,6 +904,7 @@ impl Agent {
sync.close();
}
self.prepared = false;
self.deferred_sync = None;
#[cfg(feature = "system-helper")]
{
self.prepared_request = None;
@@ -968,6 +984,19 @@ impl Agent {
clock_failure: clock.as_ref().err().map_or("", clock_code),
needs_sync,
prepared: self.prepared,
deferred_sync: self.deferred_sync.as_ref().map_or("none", |pending| {
if pending.applied.is_some() {
"local_consumption"
} else {
"fresh_response_clock"
}
}),
deferred_sync_wait_ms: self.deferred_sync.as_ref().map_or(0, |p| {
p.received_at
.elapsed()
.as_millis()
.min(u128::from(u64::MAX)) as u64
}),
helper_control,
helper_apply_unconfirmed: unconfirmed,
signed_gate_present: gate.is_some(),
@@ -1147,6 +1176,7 @@ impl Agent {
return false;
}
self.config.enable_jobs
&& self.deferred_sync.is_none()
&& !self.helper_control_pending()
&& self.channel(generation).is_ok_and(|channel| {
self.sync
@@ -1447,17 +1477,101 @@ impl Agent {
}
fn apply_sync(&mut self, generation: u64, response: SyncResponse) -> Result<()> {
ensure!(self.prepared, "UNSOLICITED_SYNC_RESPONSE");
self.prepared = false;
let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?;
let applied = sync.apply(self.journal.connection_mut(), &response, &self.clock)?;
#[cfg(feature = "system-helper")]
if applied.helper_instruction.is_some() {
self.helper_apply_unconfirmed = true;
if let Some(pending) = &self.deferred_sync {
ensure!(
pending.generation == generation && pending.response == response,
"DEFERRED_SYNC_RESPONSE_CHANGED"
);
return Ok(());
}
sync.apply_consumption(
// Authenticate exact bytes/request/channel BEFORE retaining a reply.
// Declared issued_at is used only for historical signature/profile
// verification here. The regular fresh clock gates below still decide
// whether either state-application phase may run now.
ensure!(
response.decision_bytes.len() <= 512 * 1024 && response.signature.len() == 64,
"SYNC_RESPONSE_LIMIT"
);
let decision: rmm_domain::reconciliation::ReconcileDecisionPayload =
serde_json::from_slice(&response.decision_bytes)?;
let raw:Vec<u8>=self.journal.connection().query_row("SELECT request FROM reconcile_requests WHERE id=(SELECT pending_request FROM reconcile_meta WHERE id=1)",[],|r|r.get(0))?;
ensure!(raw.len() <= rmm_domain::MAX_MESSAGE, "SYNC_REQUEST_LIMIT");
let request = SyncRequest::decode(raw.as_slice())?;
ensure!(request.encode_to_vec() == raw, "SYNC_REQUEST_CANONICAL");
reconcile::verify_response_with(
&rmm_agent_core::crypto::DalekVerifier,
self.binding.as_ref().context("JOB_BINDING_REQUIRED")?,
&request,
&self.channel(generation)?,
&response,
decision.issued_at,
)?;
self.deferred_sync = Some(DeferredSync {
generation,
response,
issued_at: decision.issued_at,
valid_until: decision.valid_until,
received_at: Instant::now(),
applied: None,
});
self.poll_sync_apply(generation, true)
}
fn poll_sync_apply(&mut self, generation: u64, open_gate: bool) -> Result<()> {
let Some(mut pending) = self.deferred_sync.take() else {
return Ok(());
};
ensure!(pending.generation == generation, "DEFERRED_SYNC_GENERATION");
use rmm_agent_windows::job_readiness::{ResponseWindow, response_window};
match response_window(
pending.issued_at,
pending.valid_until,
pending.received_at.elapsed(),
self.clock.reading().ok().map(|r| (r.own_wall, r.upper)),
) {
ResponseWindow::WaitForClock => {
self.deferred_sync = Some(pending);
return Ok(());
}
ResponseWindow::Expired => anyhow::bail!("DEFERRED_SYNC_RESPONSE_EXPIRED"),
ResponseWindow::WithinWindow => {}
}
let sync = self.sync.as_mut().context("SYNC_NOT_CONFIGURED")?;
if pending.applied.is_none() {
match sync.apply(
self.journal.connection_mut(),
&pending.response,
&self.clock,
) {
Ok(applied) => {
#[cfg(feature = "system-helper")]
if applied.helper_instruction.is_some() {
self.helper_apply_unconfirmed = true;
}
pending.applied = Some(applied);
}
Err(error) if clock_temporarily_unavailable(&error) => {
self.deferred_sync = Some(pending);
return Ok(());
}
Err(error) => return Err(error),
}
}
match sync.apply_consumption(
self.ledger.as_mut().context("LEDGER_REQUIRED")?,
&self.clock,
)?;
) {
Ok(()) => {}
Err(error) if clock_temporarily_unavailable(&error) => {
self.deferred_sync = Some(pending);
return Ok(());
}
Err(error) => return Err(error),
}
let applied = pending
.applied
.take()
.context("DEFERRED_SYNC_APPLIED_REQUIRED")?;
self.prepared = false;
if let Some(instruction) = applied.helper_instruction {
#[cfg(feature = "system-helper")]
{
@@ -1493,7 +1607,12 @@ impl Agent {
{
self.prepared_request = None;
}
self.open_fence(generation)
if open_gate {
self.open_fence(generation)
} else {
self.fence.close();
Ok(())
}
}
fn open_fence(&self, generation: u64) -> Result<()> {
if self.ready(generation) {
@@ -1955,12 +2074,32 @@ impl Agent {
self.helper_apply_unconfirmed = false;
}
let result = self.session_inner(stop).await;
self.close_gate();
self.fence.close();
#[cfg(feature = "system-helper")]
{
self.drain_helper_apply().await;
let until = Instant::now() + Duration::from_secs(70);
// Complete the already authenticated original control phases while
// their finite deadline and independent time lane still permit it.
// No job is running when this control pipeline was prepared.
while self.running.is_none() && self.deferred_sync.is_some() && Instant::now() < until {
let generation = self
.deferred_sync
.as_ref()
.expect("checked pending control")
.generation;
if self.poll_sync_apply(generation, false).is_err() {
break;
}
if self.deferred_sync.is_some() {
tokio::time::sleep(Duration::from_millis(20)).await;
}
}
self.close_gate();
self.drain_helper_apply(until).await;
self.stop_time_refresh().await;
}
#[cfg(not(feature = "system-helper"))]
self.close_gate();
result
}
async fn session_inner(&mut self, stop: &AtomicBool) -> Result<()> {
@@ -2056,6 +2195,7 @@ impl Agent {
tokio::select! {
Some(completion)=self.completed_rx.recv()=>{self.completed(generation,completion)?;needs_sync=true;},
_=tick.tick()=>{
if !stop.load(Ordering::SeqCst) && self.poll_sync_apply(generation,true).is_err(){self.close_gate();needs_sync=true;}
#[cfg(feature = "system-helper")]
if !stop.load(Ordering::SeqCst) && self.poll_helper(&channel,generation).await.is_err() {self.close_gate();needs_sync=self.sync.is_some();}
if !stop.load(Ordering::SeqCst) && let Some((pending_generation,permit))=self.deferred_permit.take() {
@@ -2069,7 +2209,7 @@ impl Agent {
let busy=self.running.is_some() || self.journal.connection().query_row("SELECT EXISTS(SELECT 1 FROM job_attempts WHERE state IN ('requesting','running','verifying'))",[],|r|r.get::<_,bool>(0))?;
if !stop.load(Ordering::SeqCst) && !busy {
if capabilities_at.elapsed()>=Duration::from_secs(60) {capabilities_at=Instant::now();if advertised!=self.capabilities(){return Ok(());}}
if self.prepared && sync_at.elapsed()>=Duration::from_secs(20){self.close_gate();needs_sync=true;}
if self.prepared && self.deferred_sync.is_none() && sync_at.elapsed()>=Duration::from_secs(20){self.close_gate();needs_sync=true;}
if self.sync.is_some() && !self.prepared && !self.helper_control_busy_for_sync() && rmm_agent_windows::job_readiness::refresh_due(needs_sync,sync_at.elapsed(),self.sync.as_ref().and_then(|s|s.validity_deadline()),self.clock.reading().ok().map(|r|r.upper)) {
if self.start_sync(&channel,generation).await.is_err(){self.close_gate();needs_sync=true;}else{needs_sync=false;}sync_at=Instant::now();
}
@@ -2365,7 +2505,7 @@ fn service_run(stop: &'static AtomicBool) -> Result<()> {
helper_checked:false,
#[cfg(feature="system-helper")]
helper_refused:false,
prepared:false,fence:Arc::new(EffectFence::default()),completed_tx,completed_rx,running:None,deferred_permit:None,readiness_worker:None,
prepared:false,deferred_sync:None,fence:Arc::new(EffectFence::default()),completed_tx,completed_rx,running:None,deferred_permit:None,readiness_worker:None,
};
agent.recover_interrupted()?;
let mut backoff = 1;
@@ -12,10 +12,19 @@ $manifestPath = Join-Path (Join-Path $bootstrap $ManifestSha256) 'successor.json
if ((Get-FileHash -LiteralPath $manifestPath).Hash.ToLowerInvariant() -cne $ManifestSha256) { throw 'Manifest changed.' }
$m = Get-Content -LiteralPath $manifestPath -Raw | ConvertFrom-Json
$fields = 'agent_build_sha256,case_id,linux_proof_sha256,new_agent_sha256,old_agent_sha256,old_pin_sha256,old_profile_sha256,old_settings_sha256,previous_publication_sha256,windows_proof_sha256'
$previousCaseId = 'c62d698d-d044-4815-acbe-3eeb383d44d5'
$requestedPreviousRevision = 4
if ($null -ne $m.PSObject.Properties['previous_case_id']) {
$fields = 'agent_build_sha256,case_id,linux_proof_sha256,new_agent_sha256,old_agent_sha256,old_pin_sha256,old_profile_sha256,old_settings_sha256,previous_case_id,previous_publication_sha256,previous_revision,windows_proof_sha256'
$previousCaseId = [guid]::ParseExact($m.previous_case_id,'D').ToString()
if ($previousCaseId -cne $m.previous_case_id -or $m.previous_revision -isnot [int] -or
$m.previous_revision -lt 4 -or $m.previous_revision -gt 1000) { throw 'Expected exact previous publication identity.' }
$requestedPreviousRevision = $m.previous_revision
}
if ((($m.PSObject.Properties.Name | Sort-Object) -join ',') -cne $fields -or
[guid]::ParseExact($m.case_id,'D').ToString() -cne $m.case_id) { throw 'Unexpected development manifest schema.' }
foreach ($p in $m.PSObject.Properties) {
if ($p.Name -cne 'case_id' -and $p.Value -cnotmatch '^[0-9a-f]{64}$') { throw 'Manifest digest format.' }
if ($p.Name -notin @('case_id','previous_case_id','previous_revision') -and $p.Value -cnotmatch '^[0-9a-f]{64}$') { throw 'Manifest digest format.' }
}
if ($m.old_agent_sha256 -ceq $m.new_agent_sha256) { throw 'No successor code.' }
@@ -38,25 +47,25 @@ if ($i -lt 0 -or $j -le $i -or $i -ne $text.LastIndexOf($first,[StringComparison
$EchoPassive = $false
$Mode = 'Read'
. ([scriptblock]::Create($text.Substring($i,$j-$i)))
$previousRevision = $requestedPreviousRevision
CheckControl $bootstrap $true
CheckControl (Split-Path $manifestPath) $true
CheckControl $manifestPath $false
$previousCase = Join-Path $bootstrap 'job-passive-pair-c62d698d-d044-4815-acbe-3eeb383d44d5'
$previousCase = Join-Path $bootstrap ('job-passive-pair-' + $previousCaseId)
$previousPublication = Join-Path $previousCase 'profile-published.json'
CheckControl $previousCase $true
CheckControl $previousPublication $false
if ((Hash $previousPublication) -cne $m.previous_publication_sha256) { throw 'Previous publication changed.' }
$previous = Get-Content -LiteralPath $previousPublication -Raw | ConvertFrom-Json
if ($previous.successor_revision -ne 4 -or $previous.configuration.sha256 -cne $m.old_profile_sha256 -or
$previous.agent.image_file.sha256 -cne $m.old_agent_sha256) { throw 'Expected actual revision 4 predecessor.' }
if ($previous.successor_revision -ne $previousRevision -or $previous.configuration.sha256 -cne $m.old_profile_sha256 -or
$previous.agent.image_file.sha256 -cne $m.old_agent_sha256) { throw 'Expected actual predecessor publication.' }
$id = $m.case_id
$work = Join-Path $bootstrap ('job-passive-pair-' + $id)
$oldHashes = [ordered]@{agent=$m.old_agent_sha256;settings=$m.old_settings_sha256;pin=$m.old_pin_sha256}
$newHashes = [ordered]@{agent=$m.new_agent_sha256}
$source = Join-Path (Join-Path $bootstrap $newHashes.agent) 'rmm-agent-windows.exe'
$profileHash = $m.old_profile_sha256
$previousRevision = 4
$previousPublicationHash = $m.previous_publication_sha256
$platformArchive = Join-Path $previousCase 'profile-platform.json'
$roleArchive = Join-Path $previousCase 'profile-role-{0}.json'
@@ -0,0 +1,80 @@
{
"schema_version": 1,
"source_files": [
{
"path": "crates/agent-windows/src/runtime.rs",
"source_sha256": "571eb94025fe0fb1fecbab050ff034d21cad8122193996606579768480e6b1cf",
"target_sha256": "a9bff2463da165f69d4e70e22bddcb13592e309c7583cc5fa9b8088c91700a85"
},
{
"path": "crates/agent-windows/src/job_readiness.rs",
"source_sha256": null,
"target_sha256": "d492f292e7deabe59dc7dd88fb02b51c7c9f60ed9b646b284eb314654e63f9f9"
},
{
"path": "crates/agent-windows/src/lib.rs",
"source_sha256": "609e6bf4cd895b81f0153113b17444fe8453212d6b691b73dcea26a63a920d45",
"target_sha256": "574e55d368e7c6668065c42f9d1898856dc659a46d21dfec5c6bd623a0d98138"
},
{
"path": "crates/agent-core/src/reconcile.rs",
"source_sha256": "d924e3cfd1f782169f3dee4dd7875cd5fba493fbaecb64e13abcb16729be9f74",
"target_sha256": "06180f8897b4a69eec4ed7cb265caa7afaf156e13283b1025fda944d0cc3e5c0"
},
{
"path": "crates/agent-windows/src/helper_runtime.rs",
"source_sha256": "e1a4896331c261f497ee9047cd2f4a40fe9232983b71ff45093c4cd1dc1fab5c",
"target_sha256": "d250c0e12f7582b1b1e890493fca8fd93103e41c7e161bb748b8c71af3ac9865"
},
{
"path": "crates/agent-core/tests/reconcile.rs",
"source_sha256": "e0ba24b22b3259b7b39727ed227612b75deaf6904bc9a563da2ad9709f6d4d79",
"target_sha256": "b1a5cc969d95ad376df6446332b2bf963acb73eb7bef6f321b0b02b15cdc6c93"
}
],
"scope": "Native clock/deferred signed response contract checks only; no new target job or update acceptance",
"results": [
{
"exit_code": 0,
"stdout": "\nrunning 1 test\ntest job_readiness::response_tests::signed_response_waits_for_fresh_clock_and_issued_at_without_extending_its_deadline ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 32 filtered out; finished in 0.01s\n\n",
"stderr": "",
"binary_sha256": "672f6e0523583fd76c6033f5f196329f62930cf05e58aa87cce6dca3d8358f8b",
"native_platform": "cloud-linux-x86_64",
"uid": 65534,
"isolated_network": true,
"no_new_privs": true,
"verified": true
},
{
"exit_code": 0,
"stdout": "\nrunning 1 test\ntest transient_clock_failure_keeps_the_same_signed_reply_for_both_control_commit_phases ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 28 filtered out; finished in 0.11s\n\n",
"stderr": "",
"binary_sha256": "a805edf38b1aa8f35c3f30bc596f28f602e62fde0f19d6a4eecee37501dcbfe0",
"native_platform": "cloud-linux-x86_64",
"uid": 65534,
"isolated_network": true,
"no_new_privs": true,
"verified": true
},
{
"exit_code": 0,
"product_job": false,
"binary_sha256": "b9375633933d07ae7d1415077ae655799781b44e2ba98799bb155d8d4554db4d",
"bootstrap_administrator": true,
"stderr": "",
"native_platform": "windows-11-x86_64",
"stdout": "\nrunning 1 test\ntest job_readiness::response_tests::signed_response_waits_for_fresh_clock_and_issued_at_without_extending_its_deadline ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 59 filtered out; finished in 0.00s\n\n",
"verified": true
},
{
"exit_code": 0,
"product_job": false,
"binary_sha256": "dba9fe4222770b11ec7e9219f9d93ab5b4641afdd3686f798d0af3b709b91a42",
"bootstrap_administrator": true,
"stderr": "",
"native_platform": "windows-11-x86_64",
"stdout": "\nrunning 1 test\ntest transient_clock_failure_keeps_the_same_signed_reply_for_both_control_commit_phases ... ok\n\ntest result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 28 filtered out; finished in 0.13s\n\n",
"verified": true
}
]
}
+43
View File
@@ -273,3 +273,46 @@ Aufnahmefrist konnte kein exakt gemeinsamer signierter Agent-/Helperstand
belegt werden. Kein Dienst wurde durch diesen Versuch gestoppt, keine
SQL-Datenzeile geändert, kein Job gestartet. Eine gesonderte rein lesende
Diagnose untersucht die abweichende Vorbedingung.
## Signierte Antworten behalten; ergänzte native Prüfungen bestanden
Die lesende Laufzeitdiagnose bestätigte denselben letzten angewandten
Entscheidungsbeleg in Agent und Helper, während neue vorbereitete
Anfragecheckpoints weiterliefen. Es gab keine neuen Verbräuche, Grants,
Helperintents, offenen Ausgaben oder gespeicherten Faults. Die Diagnose
erteilte weder Bereitschaft noch eine Reparaturfreigabe.
Die ergänzte Korrektur authentisiert genau eine Antwort gegen ihren
Originalrequest und Kanal, behält sie begrenzt und wartet auf einen frischen
100-ms-Zeitbeleg sowie das Erreichen ihres signierten Ausstellungszeitpunkts
durch die lokale Uhr. Danach werden beide normalen Commitphasen weiterhin
unabhängig geprüft. Ein bloß vorübergehend unbrauchbarer Zeitbeleg verwirft
nicht mehr die Antwort oder den bereits erfolgreichen ersten Commit.
Keine ursprüngliche Gültigkeitsfrist wird verlängert. Auch der Helper wartet
vor seinem ersten Dispatch feiner; eine unklare Antwort löst keine
Execute-Wiederholung aus.
Tatsächlich bestanden zuerst zwei gezielte Tests auf der Cloud-Linux-VM
und danach dieselben zwei nativ auf Windows: **je 2/2, keine Fehler**.
Die Coreprüfung verwendet beide echten SQLite-Commitphasen mit demselben
signierten Reply und vorübergehend ausfallender Uhr. Sie erzeugt keine Jobs,
Grants oder Zielwirkung. Der genaue eingefrorene Windows-GNU-Quellsatz
bestand zusätzlich alle Targets mit Clippy `-D warnings`.
[Native Resultate und exakte Quellen-/Binärhashes](evidence/windows-deferred-sync-20261116.json).
Der korrigierte Wartungsstopp erfasste am 16. November um **11:55:25 MEZ**
den gemeinsamen Originalstand und die exakt erhaltene, noch unbeantwortete
reine Syncanfrage unter einer bestehenden SQLite-Schreibreservierung.
Dadurch konnten weder Antwortanwendung noch neue Permitreservierung committen.
Der Agent wurde genau einmal regulär gestoppt; keine SQL-Zeile, Identität,
Signatur, Anfrage oder Ergebnis wurde geändert oder gelöscht. Der Helper
blieb erhalten. Der vorherige erfolglose Fall wurde nicht überschrieben.
Danach wurde ausschließlich die bytegleiche ursprüngliche passive
Konfiguration wieder eingesetzt und die alte Version passiv gestartet.
Der reguläre geprüfte Nachfolgerwechsel installierte um **12:06:57 MEZ**
Agent SHA256 `b24a248e1ebc7d9039c789965413c164b5f83d0f20d34f56d11d8485915905ca`
bei unverändertem Helper `59675a3cbb3a5d213fc764f38379d6b81baaf9d47a7124470cc2767d4985763e`.
Alle Geräte-/PKI-/Journal-Dateikennungen blieben erhalten. Der zugehörige
Fall ist `969d319a-d1a0-41fb-b1af-afc17a26d775`. Zeitprofilveröffentlichung
und aktiver neuer Skriptlauf sind weiterhin gesondert nachzuweisen.