Deploy reviewed Windows sync alignment with schema 20 server
Rust development slice / linux (push) Failing after 7s

Bind the administrative connection-205 review to original signed history and preserve closed readiness. Include the qualified server dependency closure, UI review, native ARM64 build provenance, and guarded deployment evidence. Migration, API/gateway replacement and TLS checks passed with unchanged job authority, protected mounts and time/database services; native Windows receipt application remains separate.
This commit is contained in:
2026-11-16 13:30:31 +01:00
parent 7b320b932e
commit cafd13bca9
34 changed files with 3865 additions and 43 deletions
+8
View File
@@ -208,6 +208,10 @@ export function validateInput(input: PlanInput): void {
if (input.action === 'run_script') {
if (privilegedScriptProfile(input.parameters, 'system') !== fullMaintenanceScriptProfile) throw new Error('SYSTEM-Skript benötigt ausdrücklich full_maintenance_v1');
} else if (input.action === 'ensure_package') validateWindowsMsiInput(input);
else if (input.action === 'reboot') {
validateWindowsReboot(input.parameters.reason, input.parameters.dependency_group, input.parameters.reconnect_timeout_seconds, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
if (Object.keys(input.parameters).some(k => !['execution_identity', 'reason', 'dependency_group', 'reconnect_timeout_seconds', 'timeout_seconds', 'max_output_bytes'].includes(k)) || (input.artifact_ids?.length ?? 0) !== 0) throw new Error('Windows-Neustart enthält fremde Parameter oder Artefakte');
}
else {
if (input.action !== 'set_service_state') throw new Error('SYSTEM ausschließlich für typisierte eigene Windows-Fixturedienste oder feste MSI-Rezepte; keine SYSTEM-Shell');
validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
@@ -233,6 +237,10 @@ export function validateSystemService(unit: unknown, state: unknown, runtime: un
if (state !== 'running' && state !== 'stopped') throw new Error('SYSTEM-Dienstzustand ausschließlich running oder stopped');
if (typeof runtime !== 'number' || !Number.isSafeInteger(runtime) || runtime < 1 || runtime > 120 || typeof output !== 'number' || !Number.isSafeInteger(output) || output < 1 || output > 65536) throw new Error('SYSTEM-Dienstlimits maximal 120 s und 64 KiB');
}
export function validateWindowsReboot(reason: unknown, group: unknown, reconnect: unknown, runtime: unknown, output: unknown): void {
if (typeof reason !== 'string' || !reason.length || new TextEncoder().encode(reason).length > 1024 || typeof group !== 'string' || !/^[A-Za-z0-9_.@-]{1,255}$/.test(group)
|| reconnect !== 180 || runtime !== 60 || typeof output !== 'number' || !Number.isSafeInteger(output) || output < 1 || output > 65536) throw new Error('Windows-SYSTEM-Neustart benötigt feste 180s Wiederkontakt, 60s Laufzeit und höchstens 64KiB Ausgabe');
}
/** These are immutable target definitions, never evidence of executable jobs. */
export function planTargetPreviews(plan: RecordValue): unknown[] | null {
if (Array.isArray(plan.resolved_targets) && plan.resolved_targets.some(value =>
+14 -2
View File
@@ -8,6 +8,7 @@ import { allowed, availableActions, parseStrictJson, powerShellApprovalBlockers,
import { RecoveryReview, recoveryAsset, recoveryTenant } from './recovery-review';
import { EchoProbeReview } from './echo-probe-review';
import { EchoCompletionReview } from './echo-completion-review';
import { SyncAlignmentReview } from './sync-alignment-review';
import { Login } from './login';
import { ConsoleOutput, outputText } from './console-output';
import { scriptApprovalBlockers, scriptPlanJobs, verifyScriptPlan } from './script-console';
@@ -51,6 +52,16 @@ export function SystemPlanNotice({ plan }: { plan: RecordValue }) {
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste SYSTEM-Dienstaktionen"><p>{systemWarning}</p><ul>{jobs.map((payload, i) => { const action = record(payload.action); return <li key={i}>Identität: system · Asset: {String(payload.asset_id)} · Dienst: {String(action.unit)} · Zielzustand: {String(action.state)}</li>; })}</ul><p>Diese Definitionen stammen aus den gespeicherten Planbytes; die vollständigen Zielpayloads und Hashes stehen darunter.</p></aside>;
}
export function WindowsRebootPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = systemPlanJobs(plan).filter(p => record(p.action).action === 'reboot');
if (!jobs.length) return null;
return <aside className="warning" aria-label="Feste Windows-SYSTEM-Neustarts"><h3>Geplanter Windows-Neustart als SYSTEM</h3>
<p>Der Agent kündigt den lokalen Neustart fünf Sekunden vorher an und erzwingt kein Schließen von Anwendungen. Erfolg benötigt einen authentisierten Wiederkontakt mit neuer Boot-ID innerhalb der festen 180 Sekunden ab zentraler Startreservierung. Bei unklarer Wirkung erfolgt kein automatischer weiterer Neustart.</p>
<ul>{jobs.map((p, i) => <li key={i}>Asset: {String(p.asset_id)} · Job: {String(p.job_id)} · Versuch: {String(p.attempt_id)} · Grund: {String(record(p.action).reason)}</li>)}</ul>
</aside>;
} catch { return <aside role="alert" className="error">Windows-Neustartplan ist nicht aus unveränderten gespeicherten Bytes verifiziert.</aside>; }
}
export function WindowsMsiPlanNotice({ plan }: { plan: RecordValue }) {
try {
const jobs = windowsMsiPlanJobs(plan); if (!jobs.length) return null;
@@ -103,7 +114,7 @@ function Devices({ tenantId, auth, selected, setSelected }: { tenantId: string;
<p>Fester Auswahlsnapshot ({selected.length}): {selected.join(', ') || 'keine Ziele'}</p>
{asset && <article><h3>Inventardetail {asset}</h3><ErrorBox error={detail.error}/>{detail.data && <><CatalogCheckNotice device={detail.data}/><JsonView value={detail.data} label="Inventar, Capabilities, Metriken, Dienste, Software, Updates, Logs und Quellen (soweit geliefert)"/></>}<AdminControl auth={auth} path={tenantPath(tenantId, `/devices/${encodeURIComponent(asset)}/revocation`)} permission="devices:revoke" title="Geräteidentität widerrufen" warning="ACHTUNG: Widerruf unterbricht die Geräteverwaltung und sperrt neue Starts. Kein Entfernen aus einer Liste, kein Rollback. Wiederaufnahme erfordert einen gesonderten sicheren Enrollment-/Recoveryprozess." done={detail.reload}/></article>}
{tenantId === recoveryTenant && asset === recoveryAsset && allowed(auth, 'inventory:read') &&
<><EchoProbeReview key={auth.principal.id + '-probe'} auth={auth}/><EchoCompletionReview key={auth.principal.id + '-completion'} auth={auth}/><RecoveryReview key={auth.principal.id} auth={auth}/></>}
<><SyncAlignmentReview key={auth.principal.id + '-alignment'} auth={auth}/><EchoProbeReview key={auth.principal.id + '-probe'} auth={auth}/><EchoCompletionReview key={auth.principal.id + '-completion'} auth={auth}/><RecoveryReview key={auth.principal.id} auth={auth}/></>}
</section>;
}
const initialParameters: Record<Action, RecordValue> = {
@@ -200,6 +211,7 @@ function PlanDetail({ tenantId, id, auth, onOperation }: { tenantId: string; id:
<p>Plan-ID: {id}</p><p>Exakter gespeicherter Planhash: <code>{stringField(plan.data, 'plan_hash')}</code></p><p>Feste Ziele: {Array.isArray(plan.data.resolved_targets) ? plan.data.resolved_targets.length : 'unknown'}. Die folgenden Zielpreviews sind unveränderliche Plandefinitionen, keine ausführbaren Jobs oder angelegten Versuche. Diese entstehen erst nach Genehmigung.</p>
<AgentUpdatePlanNotice plan={plan.data}/><ScriptPlanNotice plan={plan.data}/>
<SystemPlanNotice plan={plan.data}/>
<WindowsRebootPlanNotice plan={plan.data}/>
<WindowsMsiPlanNotice plan={plan.data}/>
<PowerShellPlanNotice plan={plan.data}/>
<QueryLogsPlanNotice plan={plan.data}/>
@@ -232,7 +244,7 @@ function OperationDetail({ tenantId, id, auth, openPlan }: { tenantId: string; i
function JobDetail({ tenantId, id, auth }: { tenantId: string; id: string; auth: Session }) {
const job = useResource(async signal => record(await request(tenantPath(tenantId, `/jobs/${encodeURIComponent(id)}`), { signal })), [tenantId, id], true);
const [error, setError] = useState<string | null>(null), [busy, setBusy] = useState(false);
return <article><h3>Job {id}</h3><ErrorBox error={job.error}/><ErrorBox error={error}/><p>verifying = Nachprüfung läuft · unknown = Wirkung unklar, kein Retry · awaiting_reboot = autorisierter Folgejob nötig. cancel_requested ist kein bestätigter Abbruch, keine Rollbackzusage.</p>{job.data && <><ConsoleOutput job={job.data}/><JsonView value={job.data} label="Vollständige Originaldaten: Versuch, Zustand, Ausgabe, Trunkierung, Nachprüfungen und Ergebnis"/></>}
return <article><h3>Job {id}</h3><ErrorBox error={job.error}/><ErrorBox error={error}/><p>verifying = Nachprüfung läuft · unknown = Wirkung unklar, kein Retry · awaiting_reboot = Neustart oder Wiederanmeldung zur Nachprüfung ausstehend. Neue Neustartjobs benötigen eine eigene Genehmigung. cancel_requested ist kein bestätigter Abbruch, keine Rollbackzusage.</p>{job.data && <><ConsoleOutput job={job.data}/><JsonView value={job.data} label="Vollständige Originaldaten: Versuch, Zustand, Ausgabe, Trunkierung, Nachprüfungen und Ergebnis"/></>}
<form onSubmit={async e => { e.preventDefault(); const reason = new FormData(e.currentTarget).get('reason'); setBusy(true); setError(null); try { await request(tenantPath(tenantId, `/jobs/${encodeURIComponent(id)}/cancel`), { csrf: auth.csrf_token, body: { reason } }); job.reload(); } catch (e) { setError(errorText(e)); } finally { setBusy(false); } }}><label>Abbruchgrund<input name="reason" required/></label><button disabled={busy}>Abbruch anfordern · nicht zurückrollen</button></form></article>;
}
function Workspace({ auth, logout }: { auth: Session; logout: () => void }) {
+13
View File
@@ -84,6 +84,19 @@ describe('immutable catalog and strict import contracts', () => {
});
});
describe('root and dedicated dev-test APT actions', () => {
it('binds a SYSTEM reboot to the fixed native profile and rejects extra effects before approval', async () => {
const action = { action: 'reboot', reason: 'Windows-MVP', dependency_group: 'windows-mvp-single', reconnect_timeout_seconds: 180 };
const value: PlanInput = { tenant_id: 't', action: 'reboot', targets: { asset_ids: ['asset'] }, parameters: { execution_identity: 'system', reason: action.reason, dependency_group: action.dependency_group, reconnect_timeout_seconds: 180, timeout_seconds: 60, max_output_bytes: 4096 }, schedule: { not_before: '', start_before: '', offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'unit' };
await expect(validateSensitiveInput(value, auth)).rejects.toThrow('system:execute');
await validateSensitiveInput(value, { ...auth, permissions: ['system:execute'] });
const make = async (change: Record<string, unknown> = {}) => {
const jobs = [{ payload: { execution_identity: 'system', asset_id: 'asset', action: { ...action, ...change }, max_runtime_seconds: 60, max_output_bytes: 4096 } }];
const raw = new TextEncoder().encode(JSON.stringify({ jobs }));
return { jobs, plan_payload_bytes: Array.from(raw), plan_hash: await sha256(raw) };
};
await verifyPlanIntegrity(await make());
for (const change of [{ reconnect_timeout_seconds: 181 }, { command: 'shutdown' }, { force: true }, { reason: '' }]) await expect(verifyPlanIntegrity(await make(change))).rejects.toThrow();
});
it('requires independent system scope and verifies the exact bounded SYSTEM service plan', async () => {
const value: PlanInput = { tenant_id: 't', action: 'set_service_state', targets: { asset_ids: ['asset'] }, parameters: { execution_identity: 'system', unit: 'RmmDiscoveryFixtureService', state: 'running', timeout_seconds: 30, max_output_bytes: 4096 }, schedule: { not_before: '', start_before: '', offline_policy: 'wait_until_deadline' }, rollout: { max_parallel: 1, halt_after_failures: 1 }, reason: 'unit only' };
for (const permissions of [undefined, [], ['root:execute']]) await expect(validateSensitiveInput(value, { ...auth, permissions })).rejects.toThrow('system:execute');
+8 -2
View File
@@ -1,4 +1,4 @@
import { Action, PlanInput, RecordValue, Session, planTargetPreviews, record, text, validateSystemService, windowsScriptProfile, logWindow, validateWindowsLogLimits, windowsEventLogFixtureSource, windowsEventLogFixtureChannel, windowsEventLogFixtureProvider, WindowsMsiManifest, MsiPostcondition, windowsMsi, windowsMsiManifest, windowsMsiAction, validateWindowsMsiInput, validateWindowsMsiLimits, msiUuid, fullMaintenanceScriptProfile, privilegedScriptProfile, validateScriptIdentityProfile } from './api';
import { Action, PlanInput, RecordValue, Session, planTargetPreviews, record, text, validateSystemService, validateWindowsReboot, windowsScriptProfile, logWindow, validateWindowsLogLimits, windowsEventLogFixtureSource, windowsEventLogFixtureChannel, windowsEventLogFixtureProvider, WindowsMsiManifest, MsiPostcondition, windowsMsi, windowsMsiManifest, windowsMsiAction, validateWindowsMsiInput, validateWindowsMsiLimits, msiUuid, fullMaintenanceScriptProfile, privilegedScriptProfile, validateScriptIdentityProfile } from './api';
import { validateAgentUpdateAction } from './agent-updates';
export const hashPattern = /^[0-9a-f]{64}$/;
@@ -85,8 +85,9 @@ export async function validateSensitiveInput(input: PlanInput, auth: Session) {
if (!allowed(auth, 'system:execute')) throw new Error('system:execute unbekannt oder nicht erteilt; root:execute enthält dieses Recht nicht');
if (input.action === 'run_script') {
if (privilegedScriptProfile(input.parameters, 'system') !== fullMaintenanceScriptProfile) throw new Error('SYSTEM ausschließlich für typisierte Aktionen oder explizit full_maintenance_v1');
} else if (input.action !== 'set_service_state' && input.action !== 'ensure_package') throw new Error('SYSTEM ausschließlich für typisierte Dienstaktionen oder feste MSI-Rezepte');
} else if (input.action !== 'set_service_state' && input.action !== 'ensure_package' && input.action !== 'reboot') throw new Error('SYSTEM ausschließlich für typisierte Dienstaktionen, feste MSI-Rezepte oder den gesonderten festen Neustart');
if (input.action === 'set_service_state') validateSystemService(input.parameters.unit, input.parameters.state, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
if (input.action === 'reboot') validateWindowsReboot(input.parameters.reason, input.parameters.dependency_group, input.parameters.reconnect_timeout_seconds, input.parameters.timeout_seconds, input.parameters.max_output_bytes);
}
if (Object.prototype.hasOwnProperty.call(input.parameters, 'windows_msi_manifest') || (input.action === 'ensure_package' && input.parameters.execution_identity === 'system')) {
const original = canonical(input), m = validateWindowsMsiInput(input); await verifyWindowsMsiManifest(m);
@@ -362,6 +363,11 @@ export async function verifyPlanIntegrity(plan: RecordValue) {
}
for (const payload of systemJobs) {
const action = record(payload.action);
if (action.action === 'reboot') {
exact(action, ['action', 'reason', 'dependency_group', 'reconnect_timeout_seconds']);
validateWindowsReboot(action.reason, action.dependency_group, action.reconnect_timeout_seconds, payload.max_runtime_seconds, payload.max_output_bytes);
continue;
}
if (action.action === 'update_agent') {
validateAgentUpdateAction(action, payload.execution_identity);
if (payload.max_runtime_seconds !== 600 || typeof payload.max_output_bytes !== 'number' || !Number.isSafeInteger(payload.max_output_bytes) || payload.max_output_bytes < 1 || payload.max_output_bytes > 65536) throw new Error('SYSTEM-Agentupdate benötigt festes600s/64KiB-Budget');
+21
View File
@@ -0,0 +1,21 @@
import { expect, it } from 'vitest';
import { canonicalJson } from './api';
import { sha256 } from './safety';
import { alignmentReview } from './sync-alignment-review';
it('binds the exact 205 witness and refuses job authority, altered history and extended receipts', async () => {
const witness = { schema_version: 1, tenant_id: '11111111-1111-4111-8111-111111111111', asset_id: 'a176520e-8a91-4e93-a78b-8e7620f430e0', agent_id: '63ea15b2-0643-403d-b5b4-cba1288dbea3',
enrollment_generation: 1, assignment_version: 1, connection_generation: 205, boot_id: 'a9ad0895-5a96-8f2c-8fb6-cfdc2d5225ea', agent_checkpoint: 10137, helper_checkpoint: 155,
agent_last_decision: '2af359c5-5b5c-4992-b445-1c00e271a288', helper_last_decision: '1a4758ad-0b39-449e-8551-16846851b09a', verification_key_id: 'a'.repeat(64),
counts: { agent_jobs: 2, agent_consumed: 1, agent_starts: 1, agent_outcomes: 1, helper_consumed: 0, helper_starts: 0, helper_outcomes: 0, system_intents: 0 } };
const witness_sha256 = await sha256(new TextEncoder().encode(canonicalJson(witness)));
const request_id = '78009224-dcb3-4877-a519-8bf3284d0572';
const receipt = { domain: 'rmm.dev.windows-sync-admin-closed-alignment.v1', schema_version: 1, request_id, witness, witness_sha256, key_id: witness.verification_key_id,
issued_at: '2026-11-16T12:00:00Z', valid_until: '2026-11-16T12:05:00Z', confirmed_by: 'simulated-testprincipal-a', approval_origin: 'dev_test_browser_simulation', testsimulation: true, ready: false, helper_ready: false, unlock: false };
const view = { request_id, witness, witness_sha256, receipt };
expect((await alignmentReview(view)).witness_sha256).toBe(witness_sha256);
for (const changed of [{ ready: true }, { helper_ready: true }, { unlock: true }, { testsimulation: false }, { confirmed_by: 'Administrator' }, { valid_until: '2026-11-16T12:05:01Z' }, { witness: { ...witness, helper_checkpoint: 134 } }]) {
await expect(alignmentReview({ ...view, receipt: { ...receipt, ...changed } })).rejects.toThrow();
}
await expect(alignmentReview({ ...view, witness: { ...witness, connection_generation: 150 } })).rejects.toThrow();
await expect(alignmentReview({ ...view, witness: { ...witness, counts: { ...witness.counts, helper_consumed: 1 } } })).rejects.toThrow();
});
+77
View File
@@ -0,0 +1,77 @@
import React, { useState } from 'react';
import { canonicalJson, pretty, record, RecordValue, request, Session, tenantPath } from './api';
import { allowed, sha256 } from './safety';
const tenant = '11111111-1111-4111-8111-111111111111';
const asset = 'a176520e-8a91-4e93-a78b-8e7620f430e0';
const agent = '63ea15b2-0643-403d-b5b4-cba1288dbea3';
interface Review { request_id: string; witness: RecordValue; witness_sha256: string; receipt: RecordValue | null }
export async function alignmentReview(value: unknown): Promise<Review> {
const r = record(value), w = record(r.witness);
if (typeof r.request_id !== 'string' || typeof r.witness_sha256 !== 'string' ||
w.schema_version !== 1 || w.tenant_id !== tenant || w.asset_id !== asset || w.agent_id !== agent ||
canonicalJson(w.counts) !== canonicalJson({ agent_jobs: 2, agent_consumed: 1, agent_starts: 1, agent_outcomes: 1, helper_consumed: 0, helper_starts: 0, helper_outcomes: 0, system_intents: 0 }) ||
w.connection_generation !== 205 || w.enrollment_generation !== 1 || w.assignment_version !== 1 ||
w.boot_id !== 'a9ad0895-5a96-8f2c-8fb6-cfdc2d5225ea' || w.agent_checkpoint !== 10137 ||
typeof w.helper_checkpoint !== 'number' || w.helper_checkpoint < 148 ||
w.agent_last_decision !== '2af359c5-5b5c-4992-b445-1c00e271a288' ||
w.helper_last_decision !== '1a4758ad-0b39-449e-8551-16846851b09a' ||
await sha256(new TextEncoder().encode(canonicalJson(w))) !== r.witness_sha256 ||
!(r.receipt === null || (typeof r.receipt === 'object' && !Array.isArray(r.receipt)))) {
throw new Error('Der administrative Zeuge passt nicht zum ausdrücklich freigegebenen Fall 205.');
}
if (r.receipt !== null) {
const receipt = record(r.receipt);
const issued = typeof receipt.issued_at === 'string' ? Date.parse(receipt.issued_at) : NaN;
const until = typeof receipt.valid_until === 'string' ? Date.parse(receipt.valid_until) : NaN;
if (receipt.domain !== 'rmm.dev.windows-sync-admin-closed-alignment.v1' || receipt.schema_version !== 1 ||
receipt.request_id !== r.request_id || receipt.witness_sha256 !== r.witness_sha256 ||
canonicalJson(receipt.witness) !== canonicalJson(w) || receipt.key_id !== w.verification_key_id ||
receipt.confirmed_by !== 'simulated-testprincipal-a' || receipt.approval_origin !== 'dev_test_browser_simulation' ||
receipt.testsimulation !== true || receipt.ready !== false || receipt.helper_ready !== false || receipt.unlock !== false ||
!Number.isFinite(issued) || !Number.isFinite(until) || until <= issued || until - issued > 300000) {
throw new Error('Die administrative Quittung hat eine unzulässige Bindung oder behauptet Bereitschaft.');
}
}
return r as unknown as Review;
}
export function SyncAlignmentReview({ auth }: { auth: Session }) {
const [review, setReview] = useState<Review | null>(null), [checked, setChecked] = useState(false);
const [input, setInput] = useState(''), [busy, setBusy] = useState(false), [error, setError] = useState('');
const eligible = auth.principal.simulated && auth.principal.id === 'simulated-testprincipal-a' && !!auth.csrf_token && allowed(auth, 'plans:approve');
const path = tenantPath(tenant, '/windows-sync-alignment');
async function load(submit: boolean) {
setBusy(true); setChecked(false); setError(''); setReview(null);
try {
const result = await request(path, submit ? { csrf: auth.csrf_token, body: JSON.parse(input) as RecordValue } : {});
if (record(result).request_id === null) throw new Error('Noch kein unabhängig erfasster Zeuge eingereicht.');
setReview(await alignmentReview(result));
} catch (e) { setError(String(e)); } finally { setBusy(false); }
}
async function confirm() {
if (!eligible || !checked || !review || busy) return;
setBusy(true); setChecked(false); setError('');
try { setReview(await alignmentReview(await request(path + '/' + encodeURIComponent(review.request_id) + '/confirm', {
csrf: auth.csrf_token, body: { reviewed: true, witness_sha256: review.witness_sha256 } })));
} catch (e) { setReview(null); setError(String(e)); } finally { setBusy(false); }
}
return <section aria-label="Administrativer Abschluss Windows-Verbindung 205">
<h3>Administrativer Abschluss Windows-Verbindung 205</h3>
<p>Dieser ausdrücklich begrenzte Eingriff erhält beide Originalentscheidungen, Identität, Journale und bisherige Jobhistorie. Er schließt ausschließlich den belegten wirkungslosen Kontrollspalt. Die Quittung erteilt keine Bereitschaft, Entsperrung oder Jobgenehmigung. Beide Rollen müssen danach einen neuen regulären signierten Abgleich bestehen.</p>
<label>Unabhängiger nativer Zeuge (JSON)<textarea aria-label="Nativer Abgleichzeuge 205" value={input} disabled={busy} onChange={e => setInput(e.target.value)}/></label>
<button disabled={busy || !input || !auth.csrf_token} onClick={() => void load(true)}>Zeugen einreichen und Originale serverseitig prüfen</button>{' '}
<button disabled={busy} onClick={() => void load(false)}>Gespeicherten administrativen Fall prüfen</button>
{error && <p role="alert">{error}</p>}
{review && <>
<p>Verbindung 205 · Agentcheckpoint 10137 · tatsächlicher Helpercheckpoint {String(review.witness.helper_checkpoint)} · zwei abgeschlossene Jobs · keine neue Startfreigabe</p>
<p>Geprüfter Zeugenhash: <code>{review.witness_sha256}</code></p>
<details><summary>Vollständige Originalbelege und Dateibindungen</summary><pre aria-label="Geprüfter administrativer Abgleichzeuge">{pretty(review)}</pre></details>
{review.receipt && <p>Letzte Quittung gültig bis {String(review.receipt.valid_until)}. Ein erneuter Klick erzeugt ausschließlich eine neue befristete administrative Quittung für denselben unveränderten Zeugen.</p>}
{eligible && <>
<label><input type="checkbox" checked={checked} disabled={busy} onChange={e => setChecked(e.target.checked)}/>
Ich habe genau den Fall 205, die erhaltenen Originalsignaturen, Dateibindungen und abgeschlossene Wirkungshistorie geprüft. Ich bestätige ausschließlich den geschlossenen administrativen Abgleich ohne Bereitschaft oder Jobfreigabe.</label>
<button disabled={busy || !checked} onClick={() => void confirm()}>SIMULIERT: Geschlossenen administrativen Abgleich bestätigen</button>
</>}
{review.receipt && eligible && <a href={path + '/' + encodeURIComponent(review.request_id) + '/receipt'} download="windows-sync-alignment-205.json">Signierte administrative Quittung herunterladen</a>}
</>}
</section>;
}