diff --git a/crates/agent-core/tests/reconcile.rs b/crates/agent-core/tests/reconcile.rs index db90299..b6dc331 100644 --- a/crates/agent-core/tests/reconcile.rs +++ b/crates/agent-core/tests/reconcile.rs @@ -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,Vec)=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)); +} diff --git a/crates/agent-windows/src/helper_runtime.rs b/crates/agent-windows/src/helper_runtime.rs index b16546d..ac80d7a 100644 --- a/crates/agent-windows/src/helper_runtime.rs +++ b/crates/agent-windows/src/helper_runtime.rs @@ -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; } } }; diff --git a/crates/agent-windows/src/job_readiness.rs b/crates/agent-windows/src/job_readiness.rs index 318d32e..4bc1e55 100644 --- a/crates/agent-windows/src/job_readiness.rs +++ b/crates/agent-windows/src/job_readiness.rs @@ -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, + until: chrono::DateTime, + held: std::time::Duration, + reading: Option<(chrono::DateTime, chrono::DateTime)>, +) -> 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 + ); + } +} diff --git a/crates/agent-windows/src/runtime.rs b/crates/agent-windows/src/runtime.rs index 83fc8f9..c1e9969 100644 --- a/crates/agent-windows/src/runtime.rs +++ b/crates/agent-windows/src/runtime.rs @@ -400,6 +400,19 @@ fn needs_bound_outcome( } Ok(true) } +struct DeferredSync { + generation: u64, + response: SyncResponse, + issued_at: chrono::DateTime, + valid_until: chrono::DateTime, + received_at: Instant, + applied: Option, +} +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, sync: Option, prepared: bool, + deferred_sync: Option, #[cfg(feature = "system-helper")] prepared_request: Option>, #[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=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; diff --git a/deploy/windows/Install-DevelopmentAgentSuccessor.ps1 b/deploy/windows/Install-DevelopmentAgentSuccessor.ps1 index b828c52..5b89bbd 100644 --- a/deploy/windows/Install-DevelopmentAgentSuccessor.ps1 +++ b/deploy/windows/Install-DevelopmentAgentSuccessor.ps1 @@ -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' diff --git a/docs/evidence/windows-deferred-sync-20261116.json b/docs/evidence/windows-deferred-sync-20261116.json new file mode 100644 index 0000000..9455fc1 --- /dev/null +++ b/docs/evidence/windows-deferred-sync-20261116.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 + } + ] +} diff --git a/docs/windows-mvp-completion.md b/docs/windows-mvp-completion.md index 13e25c2..4e78602 100644 --- a/docs/windows-mvp-completion.md +++ b/docs/windows-mvp-completion.md @@ -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.