diff --git a/deploy/windows/console_access_hash_command.py b/deploy/windows/console_access_hash_command.py
new file mode 100644
index 0000000..6b0d670
--- /dev/null
+++ b/deploy/windows/console_access_hash_command.py
@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+"""Local CreateNew correction of the public recovery hash function alias clash.
+
+The User's H/Get-History error occurred in the old pre-effect case/config guard.
+Keep the same console case and untouched original files. No target/server call,
+alias mutation or retry of an effect; the same case-absence guard still applies.
+"""
+import argparse
+import os
+from pathlib import Path
+import re
+
+import console_access_precision as previous
+
+require, sha, save = previous.require, previous.sha, previous.save
+CASE = '5c96d3d8-1657-40c8-a6ec-c00b63a98210'
+OLD_SHA = '4977665fb092723998473f1c4be6685b1d93975176f8957bc3287d7e2f61cb69'
+OLD_NAME = 'Recover-ExistingDevAccess.ps1'
+NEW_NAME = 'Recover-ExistingDevAccess-HashFix.ps1'
+NAME = 'Get-RmmRecoveryFileSha256'
+STATE = previous.original.cb.EVIDENCE / 'dev-access-console-hash-correction'
+
+
+def corrected(raw):
+ require(previous.original.pair.raw_sha(raw) == OLD_SHA, 'exact original reviewed 5c96 public script')
+ source = raw.decode('utf-8')
+ require(source.count('function H(') == 1 and NAME not in source, 'one original hash function and fresh unique name')
+ calls = re.findall(r'\(H\s', source)
+ require(len(calls) == source.count('(H ') and calls, 'all original H calls have the reviewed spelling')
+ result = source.replace('function H(', 'function ' + NAME + '(').replace('(H ', '(' + NAME + ' ')
+ require('function H(' not in result and not re.search(r'\(H\s', result), 'no alias-sensitive hash call remains')
+ require(result.replace('function ' + NAME + '(', 'function H(').replace('(' + NAME + ' ', '(H ') == source, 'only function/command spelling changed; all effects/pins/case bytes preserved')
+ return result.encode(), len(calls)
+
+
+def build():
+ folder = previous.STATE / CASE
+ raw = (folder / OLD_NAME).read_bytes()
+ new, calls = corrected(raw)
+ STATE.mkdir(mode=0o700, parents=True, exist_ok=False)
+ previous.original.pair.write_bytes(STATE / NEW_NAME, new)
+ digest = previous.original.pair.raw_sha(new)
+ # Literal replacement, UTF8 without BOM, CreateNew, both independent hashes.
+ # No free script content, Remove-Alias, persistent policy or registry change.
+ patch = r'''$ErrorActionPreference='Stop'
+$oldPath=Join-Path (Get-Location) 'Recover-ExistingDevAccess.ps1'
+$newPath=Join-Path (Get-Location) 'Recover-ExistingDevAccess-HashFix.ps1'
+if((Get-FileHash -LiteralPath $oldPath -Algorithm SHA256).Hash.ToLowerInvariant()-cne'@@OLD@@'){throw 'Falsche Originaldatei; nichts ausfuehren'}
+if(Test-Path -LiteralPath $newPath){throw 'Korrekturdatei existiert bereits; nur lesend pruefen'}
+$text=[Text.Encoding]::UTF8.GetString([IO.File]::ReadAllBytes($oldPath))
+$text=$text.Replace('function H(','function Get-RmmRecoveryFileSha256(').Replace('(H ','(Get-RmmRecoveryFileSha256 ')
+$bytes=(New-Object Text.UTF8Encoding($false)).GetBytes($text)
+$out=[IO.File]::Open($newPath,[IO.FileMode]::CreateNew,[IO.FileAccess]::Write,[IO.FileShare]::Read)
+try{$out.Write($bytes,0,$bytes.Length);$out.Flush($true)}finally{$out.Dispose()}
+if((Get-FileHash -LiteralPath $newPath -Algorithm SHA256).Hash.ToLowerInvariant()-cne'@@NEW@@'){throw 'Korrekturhash stimmt nicht; nichts ausfuehren'}
+powershell.exe -NoProfile -ExecutionPolicy RemoteSigned -File $newPath
+'''.replace('@@OLD@@', OLD_SHA).replace('@@NEW@@', digest)
+ previous.original.pair.write_bytes(STATE / 'Create-VerifiedHashFix.ps1', patch.encode())
+ save(STATE / 'qualification.json', dict(source_sha256=sha(__file__), source_only=True, same_console_case=CASE, original_script_sha256=OLD_SHA, corrected_script_sha256=digest, renamed_call_count=calls, exact_inverse_spelling_transform=True, all_other_bytes_unchanged=True, original_script_and_zip_unchanged=True, case_absence_guard_retained=True, no_alias_mutation=True, no_server_or_vm_call=True, original_failure='Get-History/IdCannotConvert before New-Item/case or any effect'))
+ print('corrected_script_sha256=' + digest)
+ print('patch_sha256=' + sha(STATE / 'Create-VerifiedHashFix.ps1'))
+ print('renamed_hash_calls=' + str(calls))
+ print('patch=' + str((STATE / 'Create-VerifiedHashFix.ps1').resolve()))
+
+
+def main():
+ os.umask(0o077)
+ parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('phase', choices=('build',)); parser.parse_args(); build()
+
+
+if __name__ == '__main__':
+ main()
diff --git a/deploy/windows/console_access_original_bootstrap.py b/deploy/windows/console_access_original_bootstrap.py
new file mode 100644
index 0000000..4eba9ff
--- /dev/null
+++ b/deploy/windows/console_access_original_bootstrap.py
@@ -0,0 +1,77 @@
+#!/usr/bin/env python3
+"""One local provenance correction: pin the actually deployed original bootstrap.
+
+Actual User readonly values identify the published original file, not an unknown
+hash. Preserve the same absent console case and every other byte/guard/effect.
+No Windows/server access, new expiry, alias/policy change or effect retry.
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+import zipfile
+
+import console_access_hash_command as previous
+
+require, sha, save = previous.require, previous.sha, previous.save
+STATE = previous.previous.original.cb.EVIDENCE / 'dev-access-console-original-bootstrap-correction'
+MAIN = Path('/home/kevin/Schreibtisch/Coding/rust-discovery')
+OLD_NAME = 'Recover-ExistingDevAccess-HashFix.ps1'
+NEW_NAME = 'Recover-ExistingDevAccess-OriginalBootstrap.ps1'
+OLD_SCRIPT_SHA = 'd366ae1705dac3252726dedf369c04462e42534ddcf6e15dc27bba8583427d2c'
+PARENT_SOURCE_SHA = 'b682ced57bf7ac71c0b1ba67eb5a51a20dde814fe361e1ae2cc17872147444ad'
+REPO_BOOTSTRAP_SHA = '9e992602034026efbe17f833d4d6be694da3e223ac6b4a394c502eb140ec0189'
+PUBLISHED_BOOTSTRAP_SHA = '332ceeedf49f597eac353e0ef1f6e614c85cef20a5a20cce68d947085aa9d50f'
+CONFIG_SHA = '4ad28ec55027718a4e384c79ff7cc15ec9c798411a991a5d479e960310ed6823'
+BUNDLE_SHA = 'cba159469efad9039562633fd60213d8f6a62f169fc3d1bba915e49d22c764d2'
+REPAIR_BUNDLE_SHA = '2558448b7812b95de1612fca5f11da8f4a868764fb45666b128d03eb0c423eb4'
+
+
+def build(facts_path):
+ require(sha(previous.__file__) == PARENT_SOURCE_SHA, 'immutable reviewed parent hash fix source')
+ facts = previous.previous.original.cb.contract.protected_json(facts_path)
+ require(set(facts) == {'case_present', 'config_sha256', 'bootstrap_sha256', 'configured_expiry', 'account_expiry_filetime'} and facts['case_present'] is False and facts['config_sha256'] == CONFIG_SHA and facts['bootstrap_sha256'] == PUBLISHED_BOOTSTRAP_SHA and facts['configured_expiry'] == '2026-11-14T12:55:31.254999+00:00' and facts['account_expiry_filetime'] == '134391345312549990', 'exact actual User readonly original baseline, no unknown hash adoption')
+ public = MAIN / 'devstate/windows-bootstrap'
+ require(sha(public / 'windows-dev-access.zip') == BUNDLE_SHA and sha(public / 'windows-dev-repair.zip') == REPAIR_BUNDLE_SHA, 'immutable originally published bundles')
+ with zipfile.ZipFile(public / 'windows-dev-access.zip') as archive:
+ bootstrap = archive.read('Bootstrap-DevAccess.ps1'); config = archive.read('bootstrap-public.json')
+ with zipfile.ZipFile(public / 'windows-dev-repair.zip') as archive:
+ repair = json.loads(archive.read('repair-public.json'))
+ raw_sha = previous.previous.original.pair.raw_sha
+ require(raw_sha(bootstrap) == PUBLISHED_BOOTSTRAP_SHA == repair['previous_bootstrap_sha256'] and raw_sha(config) == CONFIG_SHA, 'actual file equals original publication and independently pinned repair prerequisite')
+ original_path = previous.STATE / OLD_NAME
+ require(sha(original_path) == OLD_SCRIPT_SHA, 'exact reviewed parent PS1')
+ source = original_path.read_bytes().decode('utf-8')
+ old = "$expectedBootstrap='" + REPO_BOOTSTRAP_SHA + "'"
+ new = "$expectedBootstrap='" + PUBLISHED_BOOTSTRAP_SHA + "'"
+ require(source.count(old) == 1 and new not in source, 'single exact original constant')
+ corrected = source.replace(old, new, 1)
+ require(corrected.replace(new, old, 1) == source, 'all other bytes including expiry/case/alias/clock/effects unchanged')
+ STATE.mkdir(mode=0o700, parents=True, exist_ok=False)
+ save(STATE / 'actual-user-readonly.json', facts)
+ previous.previous.original.pair.write_bytes(STATE / NEW_NAME, corrected.encode())
+ digest = raw_sha(corrected.encode())
+ patch = r'''$ErrorActionPreference='Stop'
+$inputPath=Join-Path (Get-Location) 'Recover-ExistingDevAccess-HashFix.ps1';$newPath=Join-Path (Get-Location) 'Recover-ExistingDevAccess-OriginalBootstrap.ps1'
+if((Get-FileHash -LiteralPath $inputPath -Algorithm SHA256).Hash.ToLowerInvariant()-cne'@@INPUT@@'-or(Test-Path -LiteralPath $newPath)){throw 'Originalhash falsch oder neue Datei bereits vorhanden; nichts ausfuehren'}
+$text=[Text.Encoding]::UTF8.GetString([IO.File]::ReadAllBytes($inputPath));$text=$text.Replace("`$expectedBootstrap='@@OLD@@'","`$expectedBootstrap='@@PIN@@'");$bytes=(New-Object Text.UTF8Encoding($false)).GetBytes($text);$file=[IO.File]::Open($newPath,'CreateNew','Write','Read');try{$file.Write($bytes,0,$bytes.Length);$file.Flush($true)}finally{$file.Dispose()}
+if((Get-FileHash -LiteralPath $newPath -Algorithm SHA256).Hash.ToLowerInvariant()-cne'@@OUTPUT@@'){throw 'Neuer Hash falsch; nichts ausfuehren'}
+powershell.exe -NoProfile -ExecutionPolicy RemoteSigned -File $newPath
+'''
+ for token, value in {'INPUT': OLD_SCRIPT_SHA, 'OLD': REPO_BOOTSTRAP_SHA, 'PIN': PUBLISHED_BOOTSTRAP_SHA, 'OUTPUT': digest}.items():
+ patch = patch.replace('@@' + token + '@@', value)
+ previous.previous.original.pair.write_bytes(STATE / 'Create-VerifiedOriginalBootstrapFix.ps1', patch.encode())
+ save(STATE / 'qualification.json', dict(source_only=True, source_sha256=sha(__file__), parent_source_sha256=PARENT_SOURCE_SHA, actual_user_readonly_sha256=sha(STATE / 'actual-user-readonly.json'), same_console_case=previous.CASE, input_script_sha256=OLD_SCRIPT_SHA, corrected_script_sha256=digest, original_bundle_sha256=BUNDLE_SHA, repair_bundle_sha256=REPAIR_BUNDLE_SHA, published_bootstrap_sha256=PUBLISHED_BOOTSTRAP_SHA, corrected_exactly_one_constant=True, all_other_bytes_unchanged=True, no_unknown_hash_adoption=True, original_scripts_and_zip_retained=True, no_windows_or_server_access=True))
+ print('source_sha256=' + sha(__file__))
+ print('corrected_script_sha256=' + digest)
+ print('patch_sha256=' + sha(STATE / 'Create-VerifiedOriginalBootstrapFix.ps1'))
+ print('patch=' + str((STATE / 'Create-VerifiedOriginalBootstrapFix.ps1').resolve()))
+
+
+def main():
+ os.umask(0o077)
+ parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('phase',choices=('build',));parser.add_argument('--actual-user-readonly',required=True,type=Path);args=parser.parse_args();build(args.actual_user_readonly)
+
+
+if __name__ == '__main__':
+ main()
diff --git a/deploy/windows/console_access_precision.py b/deploy/windows/console_access_precision.py
new file mode 100644
index 0000000..1d25088
--- /dev/null
+++ b/deploy/windows/console_access_precision.py
@@ -0,0 +1,101 @@
+#!/usr/bin/env python3
+"""New public console package correcting only the old AccountExpires guard.
+
+Local only: reads the immutable completed server-only recovery case and its
+public package, never contacts Windows/server and cannot change a server lease.
+The same active server expiry/key/pins remain bound. The old package is retained.
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+import uuid
+import zipfile
+
+import console_access_recovery as original
+
+require, sha, save = original.require, original.sha, original.save
+STATE = original.cb.EVIDENCE / 'dev-access-console-precision-correction'
+PARENT_ID = '4b6506a7-6c3e-4cca-a497-618fa8666300'
+PARENT_SOURCE_SHA = '703fb5e4ae04d8555bad858c5d7b2ac4880e06d6fa951010acd43f7201a58053'
+PARENT_INTENT_SHA = 'cd827d4056fb0045f23bff1fd9bd21b6137b53f063fe8215ad0945c2013cc44a'
+PARENT_ENTER_SHA = '2185a88fc32db72119a584d84a46fb25cfca5f32f6e0c4ee5b7cf0728a361317'
+PARENT_READBACK = 'readback-754e47df-25e0-4c0b-a411-56b3d350ace5.json'
+PARENT_READBACK_SHA = 'f6e3f69a6cd4f006d00c90cadd8bfd47f94e954f1297bea5f6eecc4fd27d3787'
+EXPIRY = '2026-11-15T13:05:58+00:00'
+AUTHORIZED_SHA = 'fef4db300dd39fba9b52428817f453451c251c7768dd2fb6a76b39dd110dbbf2'
+NAMES = ('Recover-ExistingDevAccess.ps1', 'public-recovery.json', 'README.txt')
+
+
+def replace_once(text, old, new):
+ require(text.count(old) == 1, 'one exact reviewed precision/provenance replacement')
+ return text.replace(old, new, 1)
+
+
+def corrected_script(source, ident):
+ require(str(uuid.UUID(ident)) == ident, 'new canonical console UUID')
+ # The original cfg bytes/hash and its exact expiry string have already been
+ # verified before this line. Derive ONE full 64-bit FILETIME, no rounding,
+ # alternative value, tolerance or claim of a measured VM account value.
+ old = "$account=Get-LocalUser -Name 'rmm-dev';if(!$account.Enabled-or!$account.AccountExpires-or$account.AccountExpires.ToUniversalTime().ToFileTimeUtc().ToString()-cne'134391345310000000'){throw 'Existing original expired account only'}"
+ new = "$expectedOldAccountFiletime=[DateTimeOffset]::Parse($cfg.expires_at).UtcDateTime.ToFileTimeUtc().ToString()\n$account=Get-LocalUser -Name 'rmm-dev';if(!$account.Enabled-or!$account.AccountExpires-or$account.AccountExpires.ToUniversalTime().ToFileTimeUtc().ToString()-cne$expectedOldAccountFiletime){throw 'Existing original expired account precision mismatch; stop for readonly inspection'}"
+ result = replace_once(source, old, new)
+ result = replace_once(result, "$recoveryId='" + PARENT_ID + "'", "$recoveryId='" + ident + "'")
+ result = replace_once(result, "@{id=$recoveryId;new_expiry=$newExpiry;original_config_sha256=", "@{id=$recoveryId;parent_server_case='" + PARENT_ID + "';parent_server_enter_sha256='" + PARENT_ENTER_SHA + "';new_expiry=$newExpiry;original_config_sha256=")
+ effect = '[IO.File]::Replace($candidate,$config,$nativeBackup)'
+ require(result.split(effect, 1)[1] == source.split(effect, 1)[1], 'all three mutation steps/start behavior unchanged')
+ require(result.count('Start-ScheduledTask -TaskName $taskName') == 1 and '134391345310000000' not in result, 'one original task start, no obsolete rounded guard')
+ return result
+
+
+def parent():
+ require(sha(original.__file__) == PARENT_SOURCE_SHA, 'immutable historical source, no rebase')
+ folder = original.STATE / PARENT_ID
+ require(sha(folder / 'intent.json') == PARENT_INTENT_SHA and sha(folder / 'server-entered.json') == PARENT_ENTER_SHA and sha(folder / PARENT_READBACK) == PARENT_READBACK_SHA, 'exact existing server-only CAS and independent readback')
+ intent = original.cb.contract.protected_json(folder / 'intent.json')
+ entered = original.cb.contract.protected_json(folder / 'server-entered.json')
+ readback = original.cb.contract.protected_json(folder / PARENT_READBACK)
+ require(intent['id'] == PARENT_ID and intent['source_sha256'] == PARENT_SOURCE_SHA and intent['payload']['new_expiry'] == EXPIRY and entered['completed'] is True and entered['authorized_sha256'] == readback['authorized_sha256'] == AUTHORIZED_SHA and entered['expiry'] == readback['expiry'] == '20261115130558Z' and readback['read_only'] is True and readback['completed'] is True, 'same already completed server lease; never a new CAS')
+ before = intent['payload']['server_before']
+ require(all(readback[field] == before[field] for field in ('profile_sha256', 'effective_sha256', 'server_host_key_sha256', 'tunnel_public_key_sha256', 'uid', 'gid', 'home', 'shell')), 'original forwarding authority/key/profile/account unchanged')
+ for name, field in ((NAMES[0], 'console_sha256'), ('README.txt', 'readme_sha256'), ('public-recovery.json', 'public_json_sha256'), ('windows-dev-access-recovery.zip', 'bundle_sha256')):
+ require(sha(folder / name) == intent[field], 'immutable original public package files')
+ return folder, intent
+
+
+def build():
+ old_folder, old_intent = parent()
+ require(original.cb.contract.now() < original.dt.datetime.fromisoformat(EXPIRY), 'existing server lease still in its fixed window')
+ ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700, parents=True)
+ save(folder / 'prepare-intent.json', dict(id=ident, source_sha256=sha(__file__), parent_server_case=PARENT_ID, parent_server_enter_sha256=PARENT_ENTER_SHA, new_server_cas=False, no_windows_or_server_access=True))
+ script = corrected_script((old_folder / NAMES[0]).read_text(), ident)
+ original.pair.write_bytes(folder / NAMES[0], script.encode())
+ digest = original.pair.raw_sha(script.encode())
+ public = dict(schema_version=1, id=ident, parent_server_case=PARENT_ID, parent_source_sha256=PARENT_SOURCE_SHA, parent_server_enter_sha256=PARENT_ENTER_SHA, parent_server_readback_sha256=PARENT_READBACK_SHA, new_expiry=EXPIRY, script_sha256=digest, no_private_keys=True, new_server_cas=False, old_account_guard='exact_derived_from_verified_config_utc_filetime', actual_vm_account_filetime_measured=False)
+ save(folder / 'public-recovery.json', public)
+ readme = (old_folder / 'README.txt').read_text()
+ require(old_intent['console_sha256'] in readme, 'original independent PS1 hash instructions')
+ readme = readme.replace(old_intent['console_sha256'], digest)
+ readme += ('\nPraezisionskorrektur: neues Konsolenpaket, neuer Fall ' + ident + '.\n'
+ 'Verwendet ausschliesslich den bereits bestaetigten Serverfall ' + PARENT_ID + ' und dieselbe UTC-Frist ' + EXPIRY + '. Keine neue Serververlaengerung.\n'
+ 'Der alte AccountExpires-Sollwert wird exakt aus der unveraenderten alten Config-UTC-Zeit einschliesslich Bruchteilen abgeleitet. Dies ist kein gemessener VM-Accountwert.\n'
+ 'Keine Rundung, Toleranz oder alternativer Sollwert. Bei Abweichung abbrechen und nur lesend pruefen lassen.\n'
+ 'Falls ein frueheres Paket bereits erfolgreich ausgefuehrt wurde: dieses Paket NICHT als Retry verwenden; der alte Config-Hashguard muss dann verweigern.\n')
+ original.pair.write_bytes(folder / 'README.txt', readme.encode())
+ bundle = folder / 'windows-dev-access-recovery.zip'
+ with zipfile.ZipFile(bundle, 'x', compression=zipfile.ZIP_DEFLATED) as archive:
+ for name in NAMES: archive.write(folder / name, name)
+ bundle.chmod(0o600)
+ intent = dict(schema_version=1, id=ident, source_sha256=sha(__file__), parent_server_case=PARENT_ID, parent_intent_sha256=PARENT_INTENT_SHA, parent_server_enter_sha256=PARENT_ENTER_SHA, parent_server_readback_sha256=PARENT_READBACK_SHA, original_bundle_sha256=old_intent['bundle_sha256'], new_expiry=EXPIRY, console_sha256=digest, public_json_sha256=sha(folder / 'public-recovery.json'), readme_sha256=sha(folder / 'README.txt'), bundle_sha256=sha(bundle), no_windows_or_server_access=True, new_server_cas=False)
+ save(folder / 'intent.json', intent)
+ print(json.dumps(dict(id=ident, intent_sha256=sha(folder / 'intent.json'), bundle=str(bundle.resolve()), bundle_sha256=intent['bundle_sha256'], console_source=str((folder / NAMES[0]).resolve()), console_sha256=digest, new_expiry=EXPIRY, parent_server_case=PARENT_ID, new_server_cas=False, no_windows_or_server_access=True)))
+
+
+def main():
+ os.umask(0o077)
+ parser = argparse.ArgumentParser(description=__doc__); parser.add_argument('phase', choices=('build',)); parser.parse_args(); build()
+
+
+if __name__ == '__main__':
+ try: main()
+ except Exception as error: print('CONSOLE_PRECISION_CORRECTION_INCOMPLETE:' + type(error).__name__); raise SystemExit(2) from None
diff --git a/deploy/windows/console_access_recovery.py b/deploy/windows/console_access_recovery.py
new file mode 100644
index 0000000..4f28cb0
--- /dev/null
+++ b/deploy/windows/console_access_recovery.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""Expired development tunnel recovery: server-only CAS + fixed public console code.
+
+No Windows access, key generation, SSH profile edit, port/download/RMM change.
+Root renews the one expired restricted authorized key first, then hands the
+reviewed public PowerShell to the User's elevated Windows console.
+"""
+import argparse
+import base64
+import datetime as dt
+import hashlib
+import inspect
+import json
+import os
+from pathlib import Path
+import subprocess
+import uuid
+import zipfile
+import client_bootstrap as cb
+import system_pipe_upgrade as pair
+import dev_access_renewal as previous
+require,sha,save=pair.require,pair.sha,pair.save
+STATE=cb.EVIDENCE/'dev-access-console-recovery'
+OLD_EXPIRY='2026-11-14T12:55:31.254999+00:00'
+
+def recover_server(payload):
+ import datetime as dt
+ import re
+ import stat
+ root=Path('/opt/rust-discovery/devstate/windows-bootstrap')
+ authorized=Path('/var/lib/rmm-win-tunnel/.ssh/authorized_keys')
+ profile=Path('/etc/ssh/sshd_config.d/80-rmm-windows-tunnel.conf')
+ ident=str(uuid.UUID(payload['id']));case=root/('console-recovery-'+ident)
+ require(payload['phase'] in ('state','enter','readback'),'fixed renewal phase')
+ def check(path,mode):
+ s=path.lstat();require(not path.is_symlink() and stat.S_ISREG(s.st_mode) and s.st_uid==0 and stat.S_IMODE(s.st_mode)==mode and s.st_size<65536,'protected original transport file')
+ def digest(path):return hashlib.sha256(path.read_bytes()).hexdigest()
+ check(authorized,0o644);check(profile,0o644)
+ account=pwd.getpwnam('rmm-win-tunnel');require(account.pw_dir=='/var/lib/rmm-win-tunnel' and account.pw_shell=='/usr/sbin/nologin','existing forwarding-only account')
+ public=' '.join(Path('/etc/ssh/ssh_host_ed25519_key.pub').read_text().split()[:2])
+ fingerprint=subprocess.run(['ssh-keygen','-lf','/etc/ssh/ssh_host_ed25519_key.pub'],capture_output=True,check=True,timeout=10).stdout.decode().split()[1]
+ require(fingerprint=='SHA256:+NEin4XJc3CbhjQi7/ZpMIgxOrXn8AT2tlpTaXW5quw','confirmed original server host key')
+ raw=authorized.read_text();match=re.fullmatch(r'restrict,port-forwarding,permitlisten="127\.0\.0\.1:22240",expiry-time="(\d{14}Z)" (ssh-ed25519 [A-Za-z0-9+/=]{68})\n',raw)
+ require(match is not None and match[2]==payload['tunnel_public_key'],'exact unchanged forwarding key/options')
+ effective=subprocess.run(['/usr/sbin/sshd','-T','-C','user=rmm-win-tunnel,host=localhost,addr=127.0.0.1'],capture_output=True,check=True,timeout=10).stdout
+ for line in (b'allowtcpforwarding remote\n',b'permitlisten 127.0.0.1:22240\n',b'permitopen none\n',b'gatewayports no\n',b'maxsessions 0\n',b'passwordauthentication no\n'):require(line in effective,'same restricted forwarding-only profile')
+ def state():return dict(read_only=True,authorized_sha256=digest(authorized),profile_sha256=digest(profile),effective_sha256=hashlib.sha256(effective).hexdigest(),server_host_key_sha256=hashlib.sha256(public.encode()).hexdigest(),tunnel_public_key_sha256=hashlib.sha256(match[2].encode()).hexdigest(),expiry=match[1],uid=account.pw_uid,gid=account.pw_gid,home=account.pw_dir,shell=account.pw_shell)
+ if payload['phase']=='state':return state()
+ if payload['phase']=='readback':
+ value=state();value['case_exists']=case.exists();value['replace_intent']=case.exists() and (case/'replace-intent.json').exists();value['completed']=case.exists() and (case/'completed.json').exists();return value
+ old=dt.datetime.fromisoformat(payload['old_expiry']).astimezone(dt.timezone.utc);new=dt.datetime.fromisoformat(payload['new_expiry']).astimezone(dt.timezone.utc)
+ require(old.isoformat()=='2026-11-14T12:55:31.254999+00:00' and old
dt.datetime.fromisoformat(OLD_EXPIRY),'original lease actually expired')
+ ident=str(uuid.uuid4());folder=STATE/ident;folder.mkdir(mode=0o700,parents=True)
+ expiry=(cb.contract.now()+dt.timedelta(hours=24)).replace(microsecond=0)
+ console=cb.contract.protected_json(access.root/'devstate/windows-bootstrap/console-registration.json')
+ with zipfile.ZipFile(access.root/'devstate/windows-bootstrap/windows-dev-access.zip') as bundle:
+ original=bundle.read('bootstrap-public.json')
+ public=json.loads(original,object_pairs_hook=cb.contract.strict_object)
+ require(public['expires_at']==OLD_EXPIRY and public['server']=='discovery.ease-technologies.de','original public-only bundle')
+ payload=dict(id=ident,phase='state',old_expiry=OLD_EXPIRY,new_expiry=expiry.isoformat(),tunnel_public_key=console['tunnel_public_key'])
+ save(folder/'prepare-intent.json',dict(id=ident,source_sha256=sha(__file__),new_expiry=payload['new_expiry'],no_windows_access=True))
+ baseline=access.rpc(payload);require(baseline['expiry']==dt.datetime.fromisoformat(OLD_EXPIRY).strftime('%Y%m%d%H%M%SZ'),'only original expired key')
+ payload['server_before']=baseline
+ script=CONSOLE
+ for key,value in {'ID':ident,'EXPIRY':payload['new_expiry'],'CONFIG':hashlib.sha256(original).hexdigest(),'BOOTSTRAP':sha(cb.ROOT/'deploy/windows/Bootstrap-DevAccess.ps1'),'TUNNEL':console['tunnel_public_key'],'HOST':console['windows_host_public_key'],'FILETIME':str((int(expiry.timestamp())+11644473600)*10000000)}.items():
+ token='@@'+key+'@@';require(script.count(token)==1,'exact fixed public console field');script=script.replace(token,value)
+ require('@@' not in script,'complete fixed public instructions')
+ pair.write_bytes(folder/'Recover-ExistingDevAccess.ps1',script.encode())
+ save(folder/'public-recovery.json',dict(id=ident,new_expiry=payload['new_expiry'],script_sha256=pair.raw_sha(script.encode()),no_private_keys=True))
+ readme=('Bestehenden Windows-Entwicklungszugang wiederherstellen\r\n\r\n'
+ 'Nur in dieser Windows-Test-VM ausfuehren, in einer als Administrator gestarteten PowerShell.\r\n'
+ 'Der Cloudserver muss zuvor durch den Entwickler fuer diese feste Frist erneuert worden sein.\r\n'
+ 'Neue UTC-Frist: '+payload['new_expiry']+'\r\n'
+ 'ZIP-SHA256 mit dem unabhaengig mitgeteilten Downloadhash vergleichen; dann hier entpacken.\r\n'
+ 'Folgende Befehle im entpackten Verzeichnis ausfuehren:\r\n\r\n'
+ "$recoveryScript = Join-Path (Get-Location) 'Recover-ExistingDevAccess.ps1'\r\n"
+ "if ((Get-FileHash -LiteralPath $recoveryScript -Algorithm SHA256).Hash.ToLowerInvariant() -cne '"+pair.raw_sha(script.encode())+"') { throw 'Falsche Recoverydatei' }\r\n"
+ 'Unblock-File -LiteralPath $recoveryScript\r\n'
+ 'powershell.exe -NoProfile -ExecutionPolicy RemoteSigned -File $recoveryScript\r\n\r\n'
+ 'Unblock-File betrifft nur diese exakt gepruefte heruntergeladene Datei; RemoteSigned nur diesen Bootstrapprozess.\r\n'
+ 'Keine globale Policy/GPO aendern. Falls eine Richtlinie oder Pruefung verweigert: stoppen, Fehlermeldung melden, nicht erneut ausfuehren.\r\n'
+ 'Das Skript behaelt Schluessel, Pins, SSH-Profil und Taskdefinition bei, erneuert nur die Ablaufzeit und startet den Originaltunnel einmal.\r\n'
+ 'Keine Installation, ACL-Reparatur, RMM-Aktion, Reboot oder Update. Private Schluessel werden nicht gelesen/ausgegeben.\r\n'
+ 'Nach Erfolg bitte nur die Abschlusszeile melden, keine Schluessel oder Zugangsdaten. Bei Fehler den Zustand fuer lesende Kontrolle behalten.\r\n')
+ pair.write_bytes(folder/'README.txt',readme.encode('utf-8'))
+ bundle=folder/'windows-dev-access-recovery.zip'
+ with zipfile.ZipFile(bundle,'x',compression=zipfile.ZIP_DEFLATED) as archive:
+ for name in ('Recover-ExistingDevAccess.ps1','public-recovery.json','README.txt'):
+ archive.write(folder/name,name)
+ bundle.chmod(0o600)
+ intent=dict(id=ident,source_sha256=sha(__file__),access_root=str(access.root),payload=payload,console_sha256=pair.raw_sha(script.encode()),bundle_sha256=sha(bundle),readme_sha256=sha(folder/'README.txt'),public_json_sha256=sha(folder/'public-recovery.json'))
+ save(folder/'intent.json',intent)
+ print(json.dumps(dict(id=ident,review_sha256=sha(folder/'intent.json'),console_source=str((folder/'Recover-ExistingDevAccess.ps1').resolve()),console_sha256=intent['console_sha256'],bundle=str(bundle.resolve()),bundle_sha256=sha(bundle),new_expiry=payload['new_expiry'],windows_not_accessed=True)))
+
+
+def run(access,ident,phase,review_sha):
+ require(str(uuid.UUID(ident))==ident,'canonical original recovery');folder=STATE/ident;intent=cb.contract.protected_json(folder/'intent.json')
+ require(intent['source_sha256']==sha(__file__) and intent['access_root']==str(access.root) and sha(folder/'Recover-ExistingDevAccess.ps1')==intent['console_sha256'] and sha(folder/'windows-dev-access-recovery.zip')==intent['bundle_sha256'] and sha(folder/'README.txt')==intent['readme_sha256'] and sha(folder/'public-recovery.json')==intent['public_json_sha256'],'same immutable console recovery source/public package')
+ if phase=='server-enter':
+ require(review_sha==sha(folder/'intent.json'),'explicit reviewed server-only CAS');save(folder/'server-enter-intent.json',dict(once=True))
+ payload=dict(intent['payload'],phase='enter' if phase=='server-enter' else 'readback')
+ result=access.rpc(payload);save(folder/('server-entered.json' if phase=='server-enter' else 'readback-'+str(uuid.uuid4())+'.json'),result)
+ print(json.dumps(dict(id=ident,result=result,windows_not_accessed=True,console_handoff_allowed=result.get('completed') is True)))
+
+
+def main():
+ os.umask(0o077);parser=argparse.ArgumentParser(description=__doc__);parser.add_argument('phase',choices=('prepare','server-enter','readback'));parser.add_argument('--access-root',required=True,type=Path);parser.add_argument('--id');parser.add_argument('--review-sha256');args=parser.parse_args();access=ServerAccess(args.access_root)
+ if args.phase=='prepare':require(not(args.id or args.review_sha256),'fresh server-only preparation');prepare(access)
+ else:require(args.id and ((args.phase=='server-enter')==bool(args.review_sha256)),'same case, reviewed CAS once');run(access,args.id,args.phase,args.review_sha256)
+
+
+if __name__=='__main__':
+ try:main()
+ except Exception as error:print('CONSOLE_ACCESS_RECOVERY_INCOMPLETE:'+type(error).__name__);raise SystemExit(2) from None
diff --git a/deploy/windows/dev_access_renewal.py b/deploy/windows/dev_access_renewal.py
new file mode 100644
index 0000000..53dd070
--- /dev/null
+++ b/deploy/windows/dev_access_renewal.py
@@ -0,0 +1,238 @@
+#!/usr/bin/env python3
+"""One 24h renewal of the existing restricted development SSH transport.
+
+No new key, port, shell, RMM setting, download lease, stop/kill or reboot.
+The unchanged tunnel expires naturally; one SYSTEM worker starts its original
+scheduled task at original expiry+60s. This deliberately permits a short gap.
+Lost mutation replies allow readback only. Main config publication is Root work.
+"""
+import argparse
+import base64
+import datetime as dt
+import inspect
+import json
+import os
+from pathlib import Path
+import subprocess
+import uuid
+
+import client_bootstrap as cb
+import system_pipe_upgrade as pair
+
+require, sha, canonical, save = pair.require, pair.sha, pair.canonical, pair.save
+STATE = cb.EVIDENCE / 'dev-access-renewal'
+OLD_EXPIRY = '2026-11-14T12:55:31.254999+00:00'
+OLD_UTC = dt.datetime.fromisoformat(OLD_EXPIRY)
+NEW_UTC = OLD_UTC.replace(microsecond=0) + dt.timedelta(hours=24)
+START_UTC = OLD_UTC.replace(microsecond=0) + dt.timedelta(seconds=60)
+
+
+def server(payload):
+ import datetime as dt
+ import re
+ import stat
+ root=Path('/opt/rust-discovery/devstate/windows-bootstrap')
+ authorized=Path('/var/lib/rmm-win-tunnel/.ssh/authorized_keys')
+ profile=Path('/etc/ssh/sshd_config.d/80-rmm-windows-tunnel.conf')
+ ident=str(uuid.UUID(payload['id']));case=root/('renew-'+ident)
+ require(payload['phase'] in ('state','enter','readback'),'fixed renewal phase')
+ def check(path,mode):
+ s=path.lstat();require(not path.is_symlink() and stat.S_ISREG(s.st_mode) and s.st_uid==0 and stat.S_IMODE(s.st_mode)==mode and s.st_size<65536,'protected original transport file')
+ def digest(path):return hashlib.sha256(path.read_bytes()).hexdigest()
+ check(authorized,0o644);check(profile,0o644)
+ account=pwd.getpwnam('rmm-win-tunnel');require(account.pw_dir=='/var/lib/rmm-win-tunnel' and account.pw_shell=='/usr/sbin/nologin','existing forwarding-only account')
+ public=' '.join(Path('/etc/ssh/ssh_host_ed25519_key.pub').read_text().split()[:2])
+ fingerprint=subprocess.run(['ssh-keygen','-lf','/etc/ssh/ssh_host_ed25519_key.pub'],capture_output=True,check=True,timeout=10).stdout.decode().split()[1]
+ require(fingerprint=='SHA256:+NEin4XJc3CbhjQi7/ZpMIgxOrXn8AT2tlpTaXW5quw','confirmed original server host key')
+ raw=authorized.read_text();match=re.fullmatch(r'restrict,port-forwarding,permitlisten="127\.0\.0\.1:22240",expiry-time="(\d{14}Z)" (ssh-ed25519 [A-Za-z0-9+/=]{68})\n',raw)
+ require(match is not None and match[2]==payload['tunnel_public_key'],'exact unchanged forwarding key/options')
+ effective=subprocess.run(['/usr/sbin/sshd','-T','-C','user=rmm-win-tunnel,host=localhost,addr=127.0.0.1'],capture_output=True,check=True,timeout=10).stdout
+ for line in (b'allowtcpforwarding remote\n',b'permitlisten 127.0.0.1:22240\n',b'permitopen none\n',b'gatewayports no\n',b'maxsessions 0\n',b'passwordauthentication no\n'):require(line in effective,'same restricted forwarding-only profile')
+ def state():return dict(read_only=True,authorized_sha256=digest(authorized),profile_sha256=digest(profile),effective_sha256=hashlib.sha256(effective).hexdigest(),server_host_key_sha256=hashlib.sha256(public.encode()).hexdigest(),tunnel_public_key_sha256=hashlib.sha256(match[2].encode()).hexdigest(),expiry=match[1],uid=account.pw_uid,gid=account.pw_gid,home=account.pw_dir,shell=account.pw_shell)
+ if payload['phase']=='state':return state()
+ if payload['phase']=='readback':
+ value=state();value['case_exists']=case.exists();value['replace_intent']=case.exists() and (case/'replace-intent.json').exists();value['completed']=case.exists() and (case/'completed.json').exists();return value
+ old=dt.datetime.fromisoformat(payload['old_expiry']).astimezone(dt.timezone.utc);new=dt.datetime.fromisoformat(payload['new_expiry']).astimezone(dt.timezone.utc)
+ require(old.isoformat()=='2026-11-14T12:55:31.254999+00:00' and new==old.replace(microsecond=0)+dt.timedelta(hours=24) and dt.datetime.now(dt.timezone.utc)65536)throw new InvalidOperationException("Token size");
+ IntPtr p=Marshal.AllocHGlobal(needed);if(!GetTokenInformation(token,kind,p,needed,out bytes)){Marshal.FreeHGlobal(p);throw new Win32Exception();}return p;
+ }
+ public static Dictionary Proof(Held h,int pid,string owner,string serviceSid,string image){
+ if(!Alive(h))throw new InvalidOperationException("Process not alive");
+ long creation,exit,kernel,user;if(!GetProcessTimes(h,out creation,out exit,out kernel,out user))throw new Win32Exception();
+ StringBuilder path=new StringBuilder(32768);uint length=32768;if(!QueryFullProcessImageName(h,0,path,ref length)||!String.Equals(path.ToString(),image,StringComparison.OrdinalIgnoreCase))throw new InvalidOperationException("Process image");
+ IntPtr token;if(!OpenProcessToken(h,8,out token))throw new Win32Exception();
+ try {
+ int bytes;IntPtr info=Info(token,1,out bytes);string actual;
+ try {actual=new SecurityIdentifier(Marshal.ReadIntPtr(info)).Value;}finally{Marshal.FreeHGlobal(info);}
+ if(actual!=owner)throw new InvalidOperationException("Process owner");
+ info=Info(token,2,out bytes);bool found=false;
+ try {int count=Marshal.ReadInt32(info);int offset=(int)Marshal.OffsetOf(typeof(Groups),"First");int stride=Marshal.SizeOf(typeof(SidAndAttributes));
+ if(count<0||count>1024||offset+(long)count*stride>bytes)throw new InvalidOperationException("Groups size");
+ for(int n=0;n{{"pid",pid},{"creation_filetime",creation.ToString(System.Globalization.CultureInfo.InvariantCulture)},{"owner_sid",actual},{"service_sid",serviceSid},{"service_sid_enabled",true},{"image",path.ToString()},{"kernel_handle_bound",true}};
+ }finally{CloseHandle(token);}
+ }
+}
+'@
+function FileIdentity($path,[bool]$actor=$false){
+ Check $path $false $actor;$file=[IO.File]::Open($path,[IO.FileMode]::Open,[IO.FileAccess]::Read,[IO.FileShare]::Read)
+ try{$id=New-Object RmmPipeNative+FileId;$size=[Runtime.InteropServices.Marshal]::SizeOf([type][RmmPipeNative+FileId]);if($size-ne24-or![RmmPipeNative]::GetFileInformationByHandleEx($file.SafeFileHandle,18,[ref]$id,[uint32]$size)){throw 'Native file identity'}
+ return [ordered]@{volume_serial=$id.Volume.ToString([Globalization.CultureInfo]::InvariantCulture);file_id=([BitConverter]::ToString($id.Id)).Replace('-','').ToLowerInvariant();bytes=$file.Length;acl_sha256=(AclHash $path);sha256=(Hash $path $actor)}
+ }finally{$file.Dispose()}
+}
+function Kernel($role,$record,$held){
+ $owner='S-1-5-19';$sid=$agentSid;$image=$agentBinary;if($role-ceq'helper'){$owner=$sys;$sid=$helperSid;$image=$helperBinary}
+ $proof=[RmmPipeNative]::Proof($held,[int]$record.pid,$owner,$sid,$image)
+ if($proof.creation_filetime-cne$record.creation_filetime-or$proof.owner_sid-cne$record.owner_sid){throw 'SCM/kernel process identity mismatch'};return $proof
+}
+function ActualState([bool]$new){
+ $value=State $new
+ $value['files']=[ordered]@{agent=(FileIdentity $agentBinary);helper=(FileIdentity $helperBinary);settings=(FileIdentity $settings);pin=(FileIdentity $pin);config=(FileIdentity $config);ca=(FileIdentity (Join-Path $agentRoot 'server-ca.pem') $true);identity=(FileIdentity (Join-Path $agentState 'identity.json') $true);certificate=(FileIdentity (Join-Path $agentState 'device.pem') $true);private_key=(FileIdentityMetadata (Join-Path $agentState 'device.key'))}
+ foreach($role in @('agent','helper')){$record=$value.service;if($role-ceq'helper'){$record=$value.helper_service}
+ $proof=$null;if($record.state-ceq'Running'){$held=[RmmPipeNative]::Open([int]$record.pid);try{$proof=Kernel $role $record $held;if(!(JsonEqual $record (Service $role))-or![RmmPipeNative]::Alive($held)){throw 'SCM/kernel generation changed during proof'}}finally{$held.Dispose()}}
+ $value[$role+'_kernel']=$proof
+ };return $value
+}
+# FILE_READ_ATTRIBUTES only: no key content read/hash/export. This also binds
+# the private key's actual native FileID, not merely a timestamp/name.
+function FileIdentityMetadata($path){
+ Check $path $false $true;$i=Get-Item -LiteralPath $path -Force;$h=[RmmPipeNative]::CreateFile($path,0x80,7,[IntPtr]::Zero,3,0,[IntPtr]::Zero)
+ try{if($h.IsInvalid){throw 'Private metadata-only handle'};$id=New-Object RmmPipeNative+FileId;if(![RmmPipeNative]::GetFileInformationByHandleEx($h,18,[ref]$id,24)){throw 'Private metadata-only native FileID'};return @{volume_serial=$id.Volume.ToString([Globalization.CultureInfo]::InvariantCulture);file_id=([BitConverter]::ToString($id.Id)).Replace('-','').ToLowerInvariant();bytes=$i.Length;creation_ticks=$i.CreationTimeUtc.Ticks.ToString();last_write_ticks=$i.LastWriteTimeUtc.Ticks.ToString();acl_sha256=(AclHash $path);private_key_read=$false}}finally{$h.Dispose()}
+}
+function SameOriginal($before,$after){
+ Preserved $before $after $false
+ if(!(JsonEqual $before.files $after.files)){throw 'Original four files/config/private metadata CAS'}
+ foreach($role in @('service','helper_service','agent_kernel','helper_kernel')){if(!(JsonEqual $before.$role $after.$role)){throw 'Fresh original kernel/SCM generation changed; new reviewed baseline required'}}
+}
+function PreserveImmutableFiles($before,$after,[bool]$frozen){
+ Preserved $before $after $frozen
+ foreach($label in @('config','ca','identity','certificate','private_key')){if(!(JsonEqual $before.files.$label $after.files.$label)){throw 'Original immutable PKI/config native FileID/metadata changed'}}
+}
+'''
+
+# The original fixed-role SCM configuration checks are reused exactly. Unlike
+# Service(), this readback projection makes no running-process proof claim and
+# honestly exposes pending/raw State/PID without changing a service.
+READBACK_SERVICE = "\nfunction ReadbackService($role){" + u.SCRIPT.split('function Service($role){', 1)[1].split(' $processId=', 1)[0] + r'''
+ $state=[string]$service.State;if(!$state-or$state.Length-gt64){throw 'Bounded raw SCM state'}
+ return [ordered]@{state=$state;pid=[uint32]$service.ProcessId;start_name=$service.StartName;start_mode=$service.StartMode;path=$service.PathName;service_type=$service.ServiceType;sid_type=$sidType;service_acl_sha256=(BytesHash ([Text.Encoding]::UTF8.GetBytes($text)));process_identity_verified=$false;read_only=$true}
+}
+'''
+
+PHASES = r'''
+CheckControl $boot $true
+if($p.script_sha256-notmatch'^[a-f0-9]{64}$'-or$PSCommandPath-cne(Join-Path (Join-Path $boot $p.script_sha256) 'SystemPipeUpgrade.ps1')-or(Hash $PSCommandPath)-cne$p.script_sha256){throw 'Actual executing pipe-upgrade source'}
+if($p.action-ceq'baseline'){$before=ActualState $false;if($before.service.state-cne'Running'-or$before.helper_service.state-notin@('Running','Stopped')-or$before.journal.pending_inventory_events-ne0){throw 'Settled original passive baseline'};$before|ConvertTo-Json -Depth 40 -Compress;exit 0}
+function ReadCase{
+ CheckControl $folder $true;CheckControl (Join-Path $folder 'intent.json') $false;CheckControl $active $false
+ $i=Get-Content -LiteralPath (Join-Path $folder 'intent.json') -Raw|ConvertFrom-Json;$a=Get-Content -LiteralPath $active -Raw|ConvertFrom-Json
+ if((($i.payload.PSObject.Properties.Name|Sort-Object)-join',')-cne(($p.PSObject.Properties.Name|Sort-Object)-join',')){throw 'Original exact pipe payload shape'}
+ foreach($field in $p.PSObject.Properties.Name){if($field-cne'action'-and!(JsonEqual $i.payload.$field $p.$field)){throw 'Original exact pipe intent'}}
+ if($a.id-cne$p.id-or$a.script_sha256-cne$p.script_sha256-or$a.baseline_sha256-cne$p.baseline_sha256){throw 'Original active pipe intent'};return $i
+}
+if($p.action-ceq'readback'){
+ function MaybeHash($path){if(!(Test-Path -LiteralPath $path)){return $null};return Hash $path}
+ $i=ReadCase;$phases=[ordered]@{};foreach($label in @('agent-stop-attempt','agent-stopped','helper-stop-attempt','helper-stopped','helper-already-stopped','frozen','agent-backup','helper-backup','settings-backup','pin-backup','agent-replace-attempt','agent-replaced','helper-replace-attempt','helper-replaced','settings-replace-attempt','settings-replaced','pin-replace-attempt','pin-replaced','swapped','helper-start-attempt','helper-started','agent-start-attempt','agent-started','entered')){$phases[$label]=Test-Path -LiteralPath (Join-Path $folder ($label+'.json'))}
+ @{read_only=$true;id=$p.id;phase_receipts=$phases;service=(ReadbackService 'agent');helper_service=(ReadbackService 'helper');hashes=@{agent=(MaybeHash $agentBinary);helper=(MaybeHash $helperBinary);settings=(MaybeHash $settings);pin=(MaybeHash $pin)}}|ConvertTo-Json -Depth 40 -Compress;exit 0
+}
+if($p.action-ceq'finish'){
+ $i=ReadCase;$after=ActualState $true;PreserveImmutableFiles $i.before $after $false
+ CheckControl (Join-Path $folder 'frozen.json') $false;$frozen=Get-Content -LiteralPath (Join-Path $folder 'frozen.json') -Raw|ConvertFrom-Json;PreserveImmutableFiles $frozen $after $false
+ foreach($role in @('agent','helper')){CheckControl (Join-Path $folder ($role+'-started.json')) $false;$started=Get-Content -LiteralPath (Join-Path $folder ($role+'-started.json')) -Raw|ConvertFrom-Json;$live=$after.service;if($role-ceq'helper'){$live=$after.helper_service};if($live.state-cne'Running'-or!(JsonEqual $started.service $live)-or!(JsonEqual $started.kernel $after.($role+'_kernel'))){throw 'Same single-start actual component instance required'}}
+ @{read_only=$true;completed=$true;id=$p.id;native=$after;original=$i.before;frozen=$frozen}|ConvertTo-Json -Depth 40 -Compress;exit 0
+}
+if((Test-Path -LiteralPath $folder)-or(Test-Path -LiteralPath $active)){throw 'Existing pipe intent: readback only'}
+$baselineBytes=[Convert]::FromBase64String($p.baseline_base64);if((BytesHash $baselineBytes)-cne$p.baseline_sha256){throw 'Exact separately reviewed baseline bytes'};$baseline=[Text.Encoding]::UTF8.GetString($baselineBytes)|ConvertFrom-Json
+$before=ActualState $false;SameOriginal $baseline $before
+if($before.journal.pending_inventory_events-ne0-or$before.service.state-cne'Running'){throw 'Original ACK and running agent required'}
+$heldAgent=[RmmPipeNative]::Open([int]$before.service.pid);$heldHelper=$null
+try{
+ $null=Kernel 'agent' $before.service $heldAgent
+ if($before.helper_service.state-ceq'Running'){$heldHelper=[RmmPipeNative]::Open([int]$before.helper_service.pid);$null=Kernel 'helper' $before.helper_service $heldHelper}
+ New-Item -ItemType Directory -Path $folder|Out-Null;CheckControl $folder $true
+ WriteNew (Join-Path $folder 'intent.json') @{payload=$p;before=$before};WriteNew $active @{id=$p.id;script_sha256=$p.script_sha256;baseline_sha256=$p.baseline_sha256;no_jobs=$true}
+ function StopHeld($role,$record,$held){
+ $live=Service $role;if(!(JsonEqual $record $live)){throw 'SCM identity changed before own stop'};$null=Kernel $role $record $held
+ $name=$agentName;if($role-ceq'helper'){$name=$helperName};WriteNew (Join-Path $folder ($role+'-stop-attempt.json')) @{stop_once=$true;service=$record}
+ Stop-Service -Name $name;(Get-Service -Name $name).WaitForStatus([ServiceProcess.ServiceControllerStatus]::Stopped,[TimeSpan]::FromSeconds(20));if(![RmmPipeNative]::Exited($held,20000)){throw 'Pinned original process not exited'}
+ WriteNew (Join-Path $folder ($role+'-stopped.json')) @{original=$record;kernel_process_exited=$true}
+ }
+ StopHeld 'agent' $before.service $heldAgent
+ if($null-ne$heldHelper){StopHeld 'helper' $before.helper_service $heldHelper}else{if((Service 'helper').state-cne'Stopped'){throw 'Manual helper changed since reviewed stopped baseline'};WriteNew (Join-Path $folder 'helper-already-stopped.json') @{observed_stopped=$true;stop_called=$false;start_called=$false}}
+ $frozen=ActualState $false;Preserved $before $frozen $false;if($frozen.service.state-cne'Stopped'-or$frozen.helper_service.state-cne'Stopped'-or$frozen.journal.pending_inventory_events-ne0-or!(JsonEqual $before.files $frozen.files)){throw 'Stopped original complete pair/file identities'};WriteNew (Join-Path $folder 'frozen.json') $frozen
+ function Backup($label,$path,$expected){
+ $identity=FileIdentity $path;if(!(JsonEqual $identity $before.files.$label)-or$identity.sha256-cne$expected){throw 'Original backup file identity/hash/ACL'}
+ $backup=Join-Path $folder ($label+'-original');[IO.File]::Copy($path,$backup,$false);PrivateBackupAcl $backup;FlushCopy $backup
+ if((Hash $backup)-cne$expected){throw 'Exact private backup bytes'};WriteNew (Join-Path $folder ($label+'-backup.json')) @{original=$identity;backup=(FileIdentity $backup);original_sddl=(Get-Acl -LiteralPath $path).Sddl}
+ }
+ Backup 'agent' $agentBinary $p.old_agent;Backup 'helper' $helperBinary $p.old_helper;Backup 'settings' $settings $p.old_policy;Backup 'pin' $pin $p.old_pin
+ $settingBytes=[Convert]::FromBase64String($p.settings_base64);$pinBytes=[Convert]::FromBase64String($p.pin_base64);if((BytesHash $settingBytes)-cne$p.new_policy-or(BytesHash $pinBytes)-cne$p.new_pin){throw 'Deterministic closed reciprocal settings'}
+ WriteBytes (Join-Path $folder 'new-helper.json') $settingBytes;WriteBytes (Join-Path $folder 'new-agent-pin.json') $pinBytes
+ function Swap($label,$destination,$source,$oldHash,$newHash){
+ if((Service 'agent').state-cne'Stopped'-or(Service 'helper').state-cne'Stopped'){throw 'Both stopped for all four file replacements'}
+ foreach($other in @('agent','helper','settings','pin')){CheckControl (Join-Path $folder ($other+'-backup.json')) $false;if(!(Test-Path -LiteralPath (Join-Path $folder ($other+'-original')))){throw 'All four private backups precede first replacement'}}
+ $old=FileIdentity $destination;$sddl=(Get-Acl -LiteralPath $destination).Sddl;$nativeBackup=Join-Path $folder ($label+'-native-original');$candidate=Join-Path $folder ($label+'-candidate')
+ if(!(JsonEqual $old $before.files.$label)-or$old.sha256-cne$oldHash-or(Hash $source)-cne$newHash-or(Hash (Join-Path $folder ($label+'-original')))-cne$oldHash-or(Test-Path -LiteralPath $nativeBackup)){throw 'Fresh destination/source/backup CAS'}
+ [IO.File]::Copy($source,$candidate,$false);FlushCopy $candidate;$candidateId=FileIdentity $candidate;if($candidateId.sha256-cne$newHash){throw 'Complete staged replacement'}
+ WriteNew (Join-Path $folder ($label+'-replace-attempt.json')) @{old=$old;candidate=$candidateId;native_backup=$nativeBackup;source_sha256=$p.script_sha256}
+ if(!(JsonEqual (FileIdentity $destination) $old)-or!(JsonEqual (FileIdentity $candidate) $candidateId)-or(Test-Path -LiteralPath $nativeBackup)){throw 'Immediate file-ID/hash/ACL CAS'}
+ [IO.File]::Replace($candidate,$destination,$nativeBackup)
+ PrivateBackupAcl $nativeBackup;$acl=New-Object Security.AccessControl.FileSecurity;$acl.SetSecurityDescriptorSddlForm($sddl);Set-Acl -LiteralPath $destination -AclObject $acl;FlushCopy $destination
+ if((Hash $destination)-cne$newHash-or(Hash $nativeBackup)-cne$oldHash-or(AclHash $destination)-cne$old.acl_sha256){throw 'Exact actual replacement/explicit native backup/ACL'}
+ WriteNew (Join-Path $folder ($label+'-replaced.json')) @{original=$old;current=(FileIdentity $destination);native_backup=(FileIdentity $nativeBackup);original_backup=(FileIdentity (Join-Path $folder ($label+'-original')))}
+ }
+ Swap 'agent' $agentBinary (Join-Path (Join-Path $boot $p.new_agent) 'rmm-agent-windows.exe') $p.old_agent $p.new_agent
+ Swap 'helper' $helperBinary (Join-Path (Join-Path $boot $p.new_helper) 'rmm-helper-windows.exe') $p.old_helper $p.new_helper
+ Swap 'settings' $settings (Join-Path $folder 'new-helper.json') $p.old_policy $p.new_policy
+ Swap 'pin' $pin (Join-Path $folder 'new-agent-pin.json') $p.old_pin $p.new_pin
+ $swapped=ActualState $true;PreserveImmutableFiles $frozen $swapped $true;if($swapped.service.state-cne'Stopped'-or$swapped.helper_service.state-cne'Stopped'){throw 'All four new files while both stopped'};WriteNew (Join-Path $folder 'swapped.json') $swapped
+ function StartOnce($role){
+ $checked=ActualState $true;PreserveImmutableFiles $frozen $checked $false;if((Service $role).state-cne'Stopped'){throw 'First exact selected start only'};$name=$helperName;if($role-ceq'agent'){$name=$agentName}
+ WriteNew (Join-Path $folder ($role+'-start-attempt.json')) @{start_once=$true;all_four_files_verified=$true}
+ Start-Service -Name $name;(Get-Service -Name $name).WaitForStatus([ServiceProcess.ServiceControllerStatus]::Running,[TimeSpan]::FromSeconds(20))
+ $s=Service $role;$held=[RmmPipeNative]::Open([int]$s.pid);try{$kernel=Kernel $role $s $held;WriteNew (Join-Path $folder ($role+'-started.json')) @{service=$s;kernel=$kernel}}finally{$held.Dispose()}
+ }
+ StartOnce 'helper';StartOnce 'agent';$after=ActualState $true;PreserveImmutableFiles $before $after $false;WriteNew (Join-Path $folder 'entered.json') $after
+ @{entered=$true;id=$p.id;no_jobs=$true;no_reboot=$true;no_clock_change=$true}|ConvertTo-Json -Compress
+}finally{$heldAgent.Dispose();if($null-ne$heldHelper){$heldHelper.Dispose()}}
+'''
+SCRIPT = PREFIX + '\n' + NATIVE + READBACK_SERVICE + '\n' + PHASES
+PREPARE = u.transport.PREPARE_SCRIPT.replace('TransportAcceptance.ps1', 'SystemPipeUpgrade.ps1')
+LAUNCH = u.transport.LAUNCH_SCRIPT.replace('TransportAcceptance.ps1', 'SystemPipeUpgrade.ps1').replace('RmmTransportPayload', 'RmmPipeUpgradePayload')
+
+
+class Access:
+ """Explicit read-only access roots; never redirects source/manifest globals."""
+ def __init__(self, root):
+ self.root = Path(root).absolute()
+ require(self.root == self.root.resolve() and self.root != ROOT.resolve(), 'separate real access root, no symlink/copy')
+ self.evidence = self.root / 'devstate/windows-client'
+
+ def powershell(self, source, payload, timeout=180):
+ access = cb.contract.protected_json(self.root / 'credentials/windows-dev-access.json')
+ wrapped = "try {\n" + source + "\n} catch {[pscustomobject]@{bootstrap_error=$true;error_id=$_.FullyQualifiedErrorId;line=$_.InvocationInfo.ScriptLineNumber}|ConvertTo-Json -Compress;exit 1}"
+ command = 'powershell.exe -NoLogo -NoProfile -NonInteractive -ExecutionPolicy RemoteSigned -EncodedCommand ' + base64.b64encode(wrapped.encode('utf-16le')).decode()
+ result = subprocess.run(access['ssh_prefix'] + [command], input=canonical(payload) + b'\n', capture_output=True, timeout=timeout)
+ if result.returncode:
+ # Fixed error identifiers/line only; never raw stderr/payload/commands.
+ safe = dict(returncode=result.returncode, stdout_bytes=len(result.stdout), stderr_bytes=len(result.stderr))
+ try:
+ error = json.loads(result.stdout.decode('utf-8-sig'), object_pairs_hook=cb.contract.strict_object)
+ if error.get('bootstrap_error') is True:
+ safe.update(error_id=error.get('error_id'), line=error.get('line'))
+ except (ValueError, AttributeError):
+ pass
+ save(STATE / ('remote-error-' + str(uuid.uuid4()) + '.json'), safe)
+ raise RuntimeError('fixed pipe upgrade bootstrap incomplete; readback only')
+ return json.loads(result.stdout.decode('utf-8-sig'), object_pairs_hook=cb.contract.strict_object)
+
+ def stage(self, path, name):
+ require(name in ('rmm-agent-windows.exe', 'rmm-helper-windows.exe', 'RuntimeStateProbe.exe', 'SystemStateProbe.exe', 'SystemPipeUpgrade.ps1'), 'fixed stage names')
+ path = Path(path)
+ digest = sha(path)
+ prepare = u.transport.PREPARE_SCRIPT.replace('TransportAcceptance.ps1', name)
+ observed = self.powershell(prepare, dict(sha256=digest))
+ if not observed['already_uploaded']:
+ access = cb.contract.protected_json(self.root / 'credentials/windows-dev-access.json')
+ prefix = access['ssh_prefix']
+ args = ['sftp'] + [p for p in prefix[1:-1] if p != '-T'] + ['-b', '-', prefix[-1]]
+ target = '/C:/ProgramData/RustDiscoveryBootstrap/' + digest + '/' + name
+ result = subprocess.run(args, input=('put ' + json.dumps(str(path.resolve())) + ' ' + json.dumps(target) + '\n').encode(), capture_output=True, timeout=60)
+ require(result.returncode == 0, 'immutable exact bootstrap transfer; no retry')
+ observed = self.powershell(prepare, dict(sha256=digest))
+ require(observed['already_uploaded'] is True and observed['sha256'] == digest, 'same exact existing-or-new stage')
+
+ def server(self, function, payload):
+ cloud = u.transport.cloud
+ require(function in (cloud.server, u.auto.server_state, u.transport.server_transport.server_evidence), 'fixed read-only server witnesses')
+ # The inherited parser is strict data parsing, not source/eval. Its ROOT
+ # only checks the source .gitignore; its supplied path remains Main.
+ cfg = cloud.bootstrap.access.load_config(self.root / 'credentials/server.conf')
+ ssh = ['ssh', '-F', '/dev/null', '-T', '-p', cfg.get('port', '22'), '-o', 'StrictHostKeyChecking=yes', '-o', 'BatchMode=yes', '-o', 'IdentitiesOnly=yes', '-o', 'ForwardAgent=no', '-o', 'ConnectTimeout=10', '-i', str(Path(cfg['ssh_key_path']).expanduser()), cfg['username'] + '@' + cfg['address'], 'python3 -']
+ code = ('import os,json,subprocess,base64,hashlib,ssl,http.client,socket,uuid,pwd\nfrom pathlib import Path\n' + inspect.getsource(cloud.bootstrap.require) + '\n' + inspect.getsource(function) + '\ntry:\n print(json.dumps(' + function.__name__ + '(' + repr(payload) + ')))\nexcept Exception as error:\n print(json.dumps(dict(error="READONLY_WITNESS_INCOMPLETE",kind=type(error).__name__)))\n')
+ result = subprocess.run(ssh, input=code.encode(), capture_output=True, timeout=60)
+ require(result.returncode == 0 and len(result.stdout) <= 1024 * 1024, 'bounded readonly server witness')
+ value = json.loads(result.stdout, object_pairs_hook=cb.contract.strict_object)
+ require('error' not in value, 'readonly server witness incomplete')
+ return value
+
+ def server_state(self):
+ cloud = u.transport.cloud
+ linux = cb.contract.protected_json(self.root / 'devstate/cloud-mvp-final-closeout.json')
+ require(linux['verified'] is True, 'accepted Linux target only')
+ counts = {name: self.server(cloud.server, dict(kind='gate', tenant_id=tenant, agent_id=agent)) for name, tenant, agent in (
+ ('windows', cloud.TENANT, u.transport.AGENT), ('linux', linux['target']['tenant_id'], linux['target']['agent_id']))}
+ flags = self.server(u.auto.server_state, {})
+ require(u.auto.flags_disabled(flags) and counts['windows'] == dict(jobs=0, outbox=0, permits=0, unresolved=0), 'closed hooks and Windows zero-job gate')
+ return dict(counts=counts, flags=flags)
+
+ def observe(self, ident):
+ return self.server(u.transport.server_transport.server_evidence, dict(tenant_id=u.transport.cloud.TENANT, agent_id=u.transport.AGENT, fault_id=ident))
+
+ def device_and_denials(self):
+ bridge = self
+ class ReadBackend(u.transport.cloud.Backend):
+ def request(self, body):
+ if body['method'] == 'tools/call':
+ require(body['params']['name'] == 'inventory.get_device', 'only stored inventory reads')
+ else:
+ require(body['method'] in ('initialize', 'notifications/initialized'), 'only MCP read session')
+ return bridge.server(u.transport.cloud.server, dict(kind='http', path='/mcp', method='POST', headers=self.headers, body=body, principal=self.principal))
+ device = ReadBackend().call('inventory.get_device', dict(tenant_id=u.transport.cloud.TENANT, asset_id=u.transport.ASSET))
+ require(device['agent_id'] == u.transport.AGENT and device['source_id'] == 'windows.base' and set(device['capabilities']) == {'windows.base/1', 'heartbeat/1'} and device['presence'] == 'online', 'honest unchanged passive inventory')
+ denied = []
+ backend = ReadBackend('b')
+ for tenant in (u.transport.cloud.TENANT, '22222222-2222-4222-8222-222222222222'):
+ backend.sequence += 1
+ response = backend.request(dict(jsonrpc='2.0', id=backend.sequence, method='tools/call', params=dict(name='inventory.get_device', arguments=dict(tenant_id=tenant, asset_id=u.transport.ASSET))))
+ data = response.get('data', {})
+ require('error' in data or data.get('result', {}).get('isError'), 'foreign tenant denied')
+ denied.append(dict(tenant_id=tenant, denied=True))
+ return device, denied
+
+
+def dependencies():
+ modules = [cb, cb.contract, u, u.transport, u.auto, u.transport.cloud, u.transport.cloud.bootstrap, u.transport.cloud.bootstrap.access, u.transport.server_transport, u.qualification, u.qualification.feature, u.qualification.previous, u.original_helper]
+ return {str(Path(m.__file__).resolve().relative_to(ROOT)): sha(m.__file__) for m in modules}
+
+
+def guards():
+ require(sha(u.__file__) == ORIGINAL_RUNNER, 'immutable original read-only witness source')
+ require('function PinProcess' not in PREFIX and 'function Swap' not in PREFIX and 'function StopPinned' not in PREFIX and 'function StartOnce' not in PREFIX, 'historical mutations excluded')
+ require('[IO.File]::Replace($candidate,$destination,$nativeBackup)' in SCRIPT and '[IO.File]::Replace($candidate,$destination,$null)' not in SCRIPT, 'explicit additional absent native backup')
+ ordered = [SCRIPT.index(token) for token in (" StopHeld 'agent'", " Backup 'agent'", "Backup 'pin'", " Swap 'agent'", "Swap 'pin'", '$swapped=ActualState $true', " StartOnce 'helper'", "StartOnce 'agent'")]
+ require(ordered == sorted(ordered), 'all backups before any replacement; all replacements before helper/agent starts')
+ require(SCRIPT.count('Start-Service -Name $name') == SCRIPT.count('Stop-Service -Name $name') == 1, 'single fixed-role control primitives')
+ require(all(word not in SCRIPT + LAUNCH for word in ('Restart-Service', 'Restart-Computer', 'Stop-Computer', 'Set-Service', 'New-Service', 'Remove-Item', 'Invoke-Expression', 'Bypass')), 'no install/reconfigure/cleanup/reboot/automatic rollback')
+
+
+# Fresh isolated interpreter: the Pipe pack deliberately imports its transport
+# modules from Main. Reusing its module in this interpreter would accidentally
+# reuse our cached worktree client_bootstrap and corrupt the source/access split.
+# This code calls verification/read-only proof parsing ONLY, never native().
+VERIFY_PACK = r'''
+import hashlib,importlib.util,json,re,sys,uuid
+from pathlib import Path
+path=Path(sys.argv[1]);spec=importlib.util.spec_from_file_location('fixed_pipe_pack',path)
+pack=importlib.util.module_from_spec(spec);spec.loader.exec_module(pack)
+manifest_path=Path(sys.argv[2]).resolve();proof_path=Path(sys.argv[3]).resolve()
+manifest=pack.verified(manifest_path) # full current code/access hashes + Linux80/Windows58 Core proofs
+proof=pack.cb.contract.protected_json(pack.private_file(proof_path));require=pack.require
+case=proof['case_id'];require(str(uuid.UUID(case))==case and proof_path==pack.NATIVE/case/'passed.json','exact native pipe case namespace')
+require(proof['verified'] is True and proof['manifest_path']==str(manifest_path) and proof['manifest_sha256']==pack.sha(manifest_path) and proof['no_jobs'] is True and proof['clock_adapter_qualified'] is False and proof['local_service_proof'] is False and proof['native_pipe_proof'] is False,'actual same pipe manifest units, no runtime capability')
+intent=pack.cb.contract.protected_json(proof_path.parent/'intent.json')
+require(intent['id']==case and intent['manifest_path']==str(manifest_path) and intent['manifest_sha256']==pack.sha(manifest_path) and intent['runner_sha256']==pack.sha(path) and intent['script_sha256']==hashlib.sha256(pack.SCRIPT.encode()).hexdigest(),'exact executed native unit source/manifest')
+require(pack.cb.contract.protected_json(proof_path.parent/'started-local.json')['start_once'] is True,'original create-once native execution intent')
+before=pack.cb.contract.protected_json(proof_path.parent/'server-before.json')
+require(pack.auto.flags_disabled(before['flags']) and before['counts']['windows']==dict(jobs=0,outbox=0,permits=0,unresolved=0),'original closed native zero-job scope')
+actual=proof['native']
+require(actual['completed'] is True and actual['manifest_sha256']==pack.sha(manifest_path) and set(actual['reports'])==set(pack.COUNTS) and actual['both_lists_verified_before_any_test'] is True and actual['bootstrap_administrator_units'] is True and actual['local_service_proof'] is False and actual['native_pipe_proof'] is False and actual['rmm_jobs'] is False and actual['product_state_writes'] is False,'actual completed narrow units only')
+for kind,count in pack.COUNTS.items():
+ report=actual['reports'][kind];listed=report['listed'];run=report['result']
+ names=re.findall(r'^(.+): test\r?$',listed['stdout'],re.M)
+ require(report['sha256']==manifest['artifacts'][kind]['sha256'] and names==report['names']==pack.TESTS[kind] and len(set(names))==count and type(listed['exit_code']) is int and listed['exit_code']==0 and type(run['exit_code']) is int and run['exit_code']==0 and listed['timed_out'] is False and run['timed_out'] is False and re.search(r'test result: ok\. '+str(count)+r' passed; 0 failed; 0 ignored; 0 measured; 0 filtered out;',run['stdout']),'all exact 23/7 native cases, no ignored/filtered/timeout')
+print(json.dumps(manifest))
+'''
+
+
+def qualified(manifest_path, proof_path):
+ verifier = ROOT / 'deploy/windows/system_pipe_acceptance.py'
+ require(sha(verifier) == PIPE_VERIFIER_SHA, 'exact independently reviewed Pipe-v2 pack verifier')
+ result = subprocess.run([sys.executable, '-I', '-c', VERIFY_PACK, str(verifier), str(manifest_path), str(proof_path)], capture_output=True, timeout=60)
+ require(result.returncode == 0 and len(result.stdout) <= 1024 * 1024, 'fresh isolated read-only Pipe verifier/native proof; details withheld')
+ value = json.loads(result.stdout, object_pairs_hook=cb.contract.strict_object)
+ require(value['type'] == 'rmm.windows.pipe-v2-build' and value['transport_version'] == 2 and value['native_counts_expected'] == dict(lib=23, bin=7), 'Pipe-v2 manifest, never historical delegation relabeling')
+ return value
+
+
+def prior(access):
+ runtime_path = access.evidence / 'current-runtime.json'
+ components_path = access.evidence / 'current-components.json'
+ runtime = cb.contract.protected_json(runtime_path)
+ components = cb.contract.protected_json(components_path)
+ result_path = access.evidence / ('system-delegation-upgrade/' + OLD_CASE + '/result.json')
+ require(sha(result_path) == OLD_RESULT_SHA, 'independently accepted original joint result')
+ result = cb.contract.protected_json(result_path)
+ require(result['verified'] is True and result['completed'] is True and result['no_jobs'] is True and result['windows_jobs_enabled'] is False and result['clock_adapter_qualified'] is False, 'accepted closed passive generation')
+ evidence = dict(path=str(result_path.resolve()), sha256=OLD_RESULT_SHA)
+ require(runtime['case_id'] == components['case_id'] == OLD_CASE and runtime['evidence'] == components['evidence'] == evidence and runtime['binary_sha256'] == components['agent_sha256'] == OLD_AGENT and components['helper_sha256'] == OLD_HELPER and components['policy_sha256'] == OLD_POLICY and components['pin_sha256'] == OLD_PIN and runtime['transport'] == 'auto' and runtime['windows_jobs_enabled'] is False and runtime['clock_adapter_qualified'] is False and runtime['system_helper_client_feature'] is True and components['windows_jobs_enabled'] is False and components['clock_adapter_qualified'] is False and components['helper_effects_enabled'] is False, 'current accepted four-file indices, no adoption of readback')
+ recovery = access.evidence / 'system-delegation-recovery/595dd1da-0d7f-4364-9040-a75e16c6da83/acceptance.json'
+ require(sha(recovery) == '5ad5925c8928f49cd0f9d48a64f81018281b5b6e3704c799bae64a42898322bb' and cb.contract.protected_json(recovery)['verified'] is True, 'accepted original explicit-backup recovery preserved')
+ original = cb.contract.protected_json(result_path.parent / 'intent.json')
+ settings = base64.b64decode(original['payload']['settings_base64'], validate=True)
+ require(raw_sha(settings) == OLD_POLICY and raw_sha(base64.b64decode(original['payload']['pin_base64'], validate=True)) == OLD_PIN, 'exact original reciprocal public settings')
+ return dict(runtime=runtime, components=components, runtime_sha256=sha(runtime_path), components_sha256=sha(components_path), result_sha256=OLD_RESULT_SHA), result, json.loads(settings, object_pairs_hook=cb.contract.strict_object)
+
+
+def passive_settings(old, agent, helper):
+ require(set(old) == {'schema_version', 'binding', 'agent', 'helper', 'allowed_services', 'max_runtime_seconds', 'enable_effects', 'allow_reboot'} and type(old['schema_version']) is int and old['schema_version'] == 1 and old['allowed_services'] == [] and old['enable_effects'] is False and old['allow_reboot'] is False and type(old['max_runtime_seconds']) is int and old['max_runtime_seconds'] == 30 and old['agent']['binary_sha256'] == OLD_AGENT and old['helper']['binary_sha256'] == OLD_HELPER, 'exact original closed public settings')
+ require(all(isinstance(h, str) and len(h) == 64 and all(c in '0123456789abcdef' for c in h) for h in (agent, helper)), 'qualified new image hashes')
+ new = json.loads(canonical(old)); new['agent']['binary_sha256'] = agent; new['helper']['binary_sha256'] = helper
+ settings = canonical(new); policy = raw_sha(settings)
+ pin = canonical(dict(schema_version=1, binding=new['binding'], policy_sha256=policy, agent=new['agent'], helper=new['helper']))
+ return settings, pin, policy
+
+
+def leaves(access):
+ path = access.evidence / 'system-intent-bootstrap/f322a4d2-c537-4842-bf04-658ad8f814b0/acceptance.json'
+ require(sha(path) == u.INTENT_PREPARATION_SHA, 'accepted original empty-leaf preparation')
+ proof = cb.contract.protected_json(path)
+ require(proof['verified'] is True and proof['sqlite_initialized'] is False, 'not a store/SQLite qualification')
+ created_path = path.parent / 'created.json'
+ require(sha(created_path) == proof['native_created_sha256'], 'original native empty-leaf receipt')
+ created = cb.contract.protected_json(created_path)
+ items = {v['name']: v for v in created['leaves']}
+ require(set(items) == {'system-intents.sqlite', 'system-intents.sqlite-journal'} and all(v['length'] == 0 for v in items.values()), 'exact two original zero-byte leaves')
+ return {label: dict(name=name, acl_sha256=raw_sha(items[name]['sddl'].encode())) for label, name in [('database', 'system-intents.sqlite'), ('journal', 'system-intents.sqlite-journal')]}
+
+
+def remote(access, intent, action):
+ require(intent['script_sha256'] == raw_sha(SCRIPT.encode()), 'immutable new pipe bootstrap source')
+ return access.powershell(LAUNCH, dict(sha256=intent['script_sha256'], payload=dict(intent['payload'], action=action)))
+
+
+def load(ident, access):
+ require(str(uuid.UUID(ident)) == ident, 'canonical original case UUID')
+ folder = STATE / ident
+ intent = cb.contract.protected_json(folder / 'intent.json')
+ require(intent['id'] == ident and intent['runner_sha256'] == sha(__file__) and intent['script_sha256'] == raw_sha(SCRIPT.encode()) and intent['dependencies'] == dependencies() and intent['access_root'] == str(access.root), 'same source/dependencies/access root case')
+ manifest = qualified(Path(intent['manifest_path']), Path(intent['qualification_path']))
+ require(sha(intent['manifest_path']) == intent['payload']['manifest_sha256'] and sha(intent['qualification_path']) == intent['payload']['qualification_sha256'] and manifest['artifacts']['agent']['sha256'] == intent['payload']['new_agent'] and manifest['artifacts']['helper']['sha256'] == intent['payload']['new_helper'], 'same actually native-qualified new pair')
+ return folder, intent
+
+
+def prepare(access, manifest_path, proof_path):
+ guards()
+ manifest = qualified(manifest_path, proof_path)
+ indices, accepted, old = prior(access)
+ settings, pin, policy = passive_settings(old, manifest['artifacts']['agent']['sha256'], manifest['artifacts']['helper']['sha256'])
+ require(manifest['artifacts']['agent']['sha256'] != OLD_AGENT and manifest['artifacts']['helper']['sha256'] != OLD_HELPER, 'new coordinated pipe pair, no old source round')
+ ident = str(uuid.uuid4()); folder = STATE / ident; folder.mkdir(mode=0o700, parents=True)
+ script_sha = raw_sha(SCRIPT.encode())
+ payload = dict(id=ident, old_agent=OLD_AGENT, old_helper=OLD_HELPER, old_policy=OLD_POLICY, old_pin=OLD_PIN, new_agent=manifest['artifacts']['agent']['sha256'], new_helper=manifest['artifacts']['helper']['sha256'], new_policy=policy, new_pin=raw_sha(pin), config_sha256=accepted['native']['config_sha256'], probe_sha256=manifest['artifacts']['probe']['sha256'], system_probe_sha256=manifest['artifacts']['system_probe']['sha256'], manifest_sha256=sha(manifest_path), qualification_sha256=sha(proof_path), script_sha256=script_sha, settings_base64=base64.b64encode(settings).decode(), pin_base64=base64.b64encode(pin).decode(), intent_leaves=leaves(access))
+ draft = dict(id=ident, started_at=cb.contract.now().isoformat(), access_root=str(access.root), runner_sha256=sha(__file__), script_sha256=script_sha, manifest_path=str(manifest_path.resolve()), qualification_path=str(proof_path.resolve()), dependencies=dependencies(), original_indices=indices, payload=payload, no_jobs=True)
+ save(folder / 'prepare-intent.json', draft)
+ for name, data in [('runner.py', Path(__file__).read_bytes()), ('SystemPipeUpgrade.ps1', SCRIPT.encode())]:
+ write_bytes(folder / name, data)
+ for kind in ('agent', 'helper', 'probe', 'system_probe'):
+ item = manifest['artifacts'][kind]
+ require(sha(item['path']) == item['sha256'], 'qualified staged artifact bytes')
+ access.stage(item['path'], item['name'])
+ access.stage(folder / 'SystemPipeUpgrade.ps1', 'SystemPipeUpgrade.ps1')
+ before = remote(access, draft, 'baseline')
+ expected = accepted['native']
+ for field in ('agent_id', 'asset_id', 'binary_sha256', 'helper_sha256', 'policy_sha256', 'pin_sha256', 'config_sha256', 'config_acl_sha256', 'binary_acl_sha256', 'helper_binary_acl_sha256', 'settings_acl_sha256', 'pin_acl_sha256', 'public_hashes', 'identity_acls', 'private_key_metadata'):
+ require(before[field] == expected[field], 'accepted original identity/PKI/config/four-file ACLs; no private key read')
+ for field in ('database_file_id', 'database_creation', 'identity_sha256', 'schema'):
+ require(before['journal'][field] == expected['journal'][field], 'same actual original telemetry database identity')
+ for field in ('helper_ledger', 'executor_lock', 'intent_store'):
+ require(before['helper_witness'][field] == expected['helper_witness'][field], 'same actual helper DB/lock/FileIDs/zero-byte leaves')
+ for role in ('service', 'helper_service'):
+ for field in ('start_name', 'start_mode', 'path', 'service_type', 'sid_type', 'service_acl_sha256'):
+ require(before[role][field] == expected[role][field], 'original exact SCM account/config/ACL')
+ baseline = canonical(before)
+ write_bytes(folder / 'baseline.json', baseline)
+ payload.update(baseline_base64=base64.b64encode(baseline).decode(), baseline_sha256=raw_sha(baseline))
+ draft['payload'] = payload
+ save(folder / 'intent.json', draft)
+ save(folder / 'server-before.json', access.server_state())
+ central = access.observe(ident)['device']; require(central and central['agent_id'] == u.transport.AGENT, 'original stored authenticated device')
+ save(folder / 'central-before.json', central)
+ print(json.dumps(dict(id=ident, prepared=True, no_component_mutation=True, baseline_sha256=raw_sha(baseline), needs_explicit_review_before_enter=True)))
+
+
+def enter(access, ident, baseline_sha):
+ folder, intent = load(ident, access)
+ require(sha(folder / 'baseline.json') == intent['payload']['baseline_sha256'] == baseline_sha, 'explicit reviewed exact baseline required')
+ indices, _, _ = prior(access)
+ require(indices == intent['original_indices'] and access.server_state() == cb.contract.protected_json(folder / 'server-before.json'), 'both original current indices and server gates unchanged')
+ save(folder / 'enter-attempt.json', dict(enter_once=True, baseline_sha256=baseline_sha, lost_reply_readback_only=True))
+ result = remote(access, intent, 'enter')
+ require(result.get('entered') is True and result['id'] == ident, 'actual same single transition reply')
+ save(folder / 'entered.json', result)
+ print(json.dumps(dict(id=ident, entered=True, continuation='finish/readback only; never repeat enter')))
+
+
+def finish(access, ident, read_only=False):
+ folder, intent = load(ident, access)
+ action = 'readback' if read_only else 'finish'
+ observed = remote(access, intent, action)
+ save(folder / ('readback-' + str(uuid.uuid4()) + '.json'), observed)
+ require(observed['read_only'] is True and observed['id'] == ident, 'only existing case readback')
+ if read_only:
+ print(json.dumps(dict(id=ident, read_only=True, phase_receipts=observed['phase_receipts']))); return
+ require(observed['completed'] is True, 'actual complete pair preservation')
+ result_path = folder / 'result.json'
+ if result_path.exists():
+ previous = cb.contract.protected_json(result_path)
+ require(previous['verified'] is True and all(previous['native'][role] == observed['native'][role] for role in ('service', 'helper_service')), 'same completed current instances; no republication or mutation')
+ print(json.dumps(dict(id=ident, verified=True, retained_original_result=True, main_indices_published=False))); return
+ # Two genuinely new server heartbeats after both single starts, not cached
+ # contacts from baseline, and no new network-agent jobs/capabilities.
+ after = cb.contract.timestamp(intent['started_at']); baseline = cb.contract.protected_json(folder / 'central-before.json')
+ watermark = access.observe(ident)['device']
+ require(watermark and watermark['agent_id'] == u.transport.AGENT and watermark['last_contact_at'], 'post-finish server heartbeat watermark')
+ deadline = time.monotonic() + 150; first = None
+ while True:
+ evidence = access.observe(ident); device = evidence['device']
+ if device and device['transport'] == 'wss' and device['last_contact_at'] and cb.contract.timestamp(device['last_contact_at']) > cb.contract.timestamp(watermark['last_contact_at']):
+ require(all(device[k] == baseline[k] for k in ('agent_id', 'asset_id', 'enrollment_generation', 'assignment_version', 'certificate_sha256')), 'same original mTLS identity')
+ if first is None: first = evidence
+ elif device['last_contact_at'] != first['device']['last_contact_at']: break
+ require(time.monotonic() < deadline, 'two native post-upgrade heartbeats missing')
+ time.sleep(2)
+ final = remote(access, intent, 'finish'); native = final['native']
+ original = json.loads(base64.b64decode(intent['payload']['baseline_base64']), object_pairs_hook=cb.contract.strict_object)
+ require(native['journal']['pending_inventory_events'] == 0 and native['journal']['sequence'] > original['journal']['sequence'], 'fresh telemetry sequence and concrete inventory ACK')
+ device, denied = access.device_and_denials()
+ require(cb.contract.timestamp(device['observed_at']) >= after, 'fresh original stored inventory')
+ require(access.server_state() == cb.contract.protected_json(folder / 'server-before.json'), 'both target counts/policies/hooks unchanged')
+ indices, _, _ = prior(access)
+ require(indices == intent['original_indices'], 'Main current indices still original; Root owns later CAS publication')
+ pipe = u.actual_pipe_proof(native, intent)
+ result = dict(verified=True, completed=True, id=ident, original=final['original'], frozen=final['frozen'], native=native, online=dict(watermark=watermark, first=first, second=evidence), stored_inventory=device, foreign_denied=denied, native_pipe_peer_test=pipe, pipe_framing_version=2, no_jobs=True, windows_jobs_enabled=False, clock_adapter_qualified=False, system_helper_client_feature=True, helper_effects_enabled=False, no_reboot=True, no_clock_change=True, private_key_read=False, original_indices=intent['original_indices'], main_indices_published=False, manifest_path=intent['manifest_path'], manifest_sha256=intent['payload']['manifest_sha256'], qualification_sha256=intent['payload']['qualification_sha256'], runner_sha256=intent['runner_sha256'], script_sha256=intent['script_sha256'])
+ save(result_path, result)
+ print(json.dumps(dict(id=ident, verified=True, passive_preservation=True, native_pipe_peer_test=pipe, main_indices_published=False)))
+
+
+def main():
+ os.umask(0o077)
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('phase', choices=('prepare', 'enter', 'finish', 'readback', 'guards'))
+ parser.add_argument('--access-root', type=Path); parser.add_argument('--manifest', type=Path); parser.add_argument('--qualification', type=Path); parser.add_argument('--id'); parser.add_argument('--baseline-sha256')
+ args = parser.parse_args(); guards()
+ if args.phase == 'guards':
+ require(not any((args.access_root, args.manifest, args.qualification, args.id, args.baseline_sha256)), 'local source guards only'); print('PASS: local source guards; no VM action'); return
+ require(args.access_root, 'explicit separate read-only Main access root')
+ access = Access(args.access_root)
+ if args.phase == 'prepare':
+ require(args.manifest and args.qualification and not (args.id or args.baseline_sha256), 'qualified new pair and read-only baseline preparation')
+ prepare(access, args.manifest, args.qualification)
+ elif args.phase == 'enter':
+ require(args.id and args.baseline_sha256 and not (args.manifest or args.qualification), 'same prepared case and reviewed baseline hash')
+ enter(access, args.id, args.baseline_sha256)
+ else:
+ require(args.id and not (args.manifest or args.qualification or args.baseline_sha256), 'same original case readback/finish')
+ finish(access, args.id, args.phase == 'readback')
+
+
+if __name__ == '__main__':
+ try: main()
+ except Exception as error:
+ print('WINDOWS_PIPE_UPGRADE_INCOMPLETE:' + type(error).__name__)
+ raise SystemExit(2) from None
diff --git a/deploy/windows/test_system_pipe_upgrade.py b/deploy/windows/test_system_pipe_upgrade.py
new file mode 100644
index 0000000..825fc2a
--- /dev/null
+++ b/deploy/windows/test_system_pipe_upgrade.py
@@ -0,0 +1,70 @@
+"""Four local orchestration guards; no credentials/VM/Windows API calls."""
+import contextlib
+import copy
+import io
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import Mock, patch
+
+import system_pipe_upgrade as p
+
+
+def settings():
+ return dict(schema_version=1, binding={'public_fixture': True}, agent=dict(binary_sha256=p.OLD_AGENT), helper=dict(binary_sha256=p.OLD_HELPER), allowed_services=[], max_runtime_seconds=30, enable_effects=False, allow_reboot=False)
+
+
+class PipeUpgradeGuards(unittest.TestCase):
+ def test_closed_reciprocal_settings_only_change_two_image_pins(self):
+ original = settings(); preserved = copy.deepcopy(original)
+ raw, pin, policy = p.passive_settings(original, 'a' * 64, 'b' * 64)
+ changed = json.loads(raw); changed['agent']['binary_sha256'] = p.OLD_AGENT; changed['helper']['binary_sha256'] = p.OLD_HELPER
+ self.assertEqual(changed, preserved); self.assertEqual(original, preserved)
+ self.assertEqual(p.raw_sha(raw), policy); self.assertEqual(json.loads(pin)['policy_sha256'], policy)
+ for field, value in [('enable_effects', True), ('allow_reboot', True), ('allowed_services', ['foreign']), ('max_runtime_seconds', 120), ('schema_version', True)]:
+ bad = settings(); bad[field] = value
+ with self.subTest(field=field), self.assertRaises(RuntimeError): p.passive_settings(bad, 'a' * 64, 'b' * 64)
+
+ def test_historical_mutation_helpers_excluded_and_explicit_backups_ordered(self):
+ p.guards()
+ self.assertNotIn('function PinProcess', p.PREFIX)
+ self.assertNotIn('[IO.File]::Replace($candidate,$destination,$null)', p.SCRIPT)
+ self.assertIn('[RmmPipeNative]::Open([int]$before.service.pid)', p.SCRIPT)
+ self.assertNotIn('$expected=5140', p.SCRIPT)
+ self.assertIn("'helper-already-stopped.json'", p.SCRIPT)
+ self.assertIn('stop_called=$false;start_called=$false', p.SCRIPT)
+ self.assertIn("@('config','ca','identity','certificate','private_key')", p.SCRIPT)
+ self.assertEqual(p.SCRIPT.count('PreserveImmutableFiles '), 5)
+ readback = p.PHASES.split("if($p.action-ceq'readback'){", 1)[1].split("if($p.action-ceq'finish'){", 1)[0]
+ self.assertIn("(ReadbackService 'agent')", readback)
+ self.assertNotIn('(Service ', readback)
+ self.assertIn('process_identity_verified=$false', p.READBACK_SERVICE)
+ self.assertIn('pack.verified(manifest_path)', p.VERIFY_PACK)
+ self.assertIn("names==report['names']==pack.TESTS[kind]", p.VERIFY_PACK)
+ with patch.object(p.subprocess, 'run', return_value=Mock(returncode=0, stdout=b'{"type":"rmm.windows.system-delegation-build"}')):
+ with self.assertRaises(RuntimeError): p.qualified(Path('unused-fixture'), Path('unused-proof'))
+
+ def test_lost_enter_reply_cannot_repeat_target_mutation(self):
+ with tempfile.TemporaryDirectory() as temporary:
+ folder = Path(temporary); p.write_bytes(folder / 'baseline.json', b'{}')
+ digest = p.sha(folder / 'baseline.json'); indices = {'unit_fixture': True}
+ intent = dict(payload=dict(baseline_sha256=digest), original_indices=indices)
+ p.save(folder / 'server-before.json', {'unit_counts': 0})
+ access = Mock(); access.server_state.return_value = {'unit_counts': 0}
+ with patch.object(p, 'load', return_value=(folder, intent)), patch.object(p, 'prior', return_value=(indices, {}, {})), patch.object(p, 'remote', side_effect=TimeoutError('unit fixture lost reply')) as remote:
+ with self.assertRaises(TimeoutError): p.enter(access, 'fixture', digest)
+ self.assertTrue((folder / 'enter-attempt.json').exists())
+ with self.assertRaises(FileExistsError): p.enter(access, 'fixture', digest)
+ self.assertEqual(remote.call_count, 1)
+
+ def test_readback_never_queries_server_starts_or_publishes_main_indices(self):
+ with tempfile.TemporaryDirectory() as temporary:
+ access = Mock(); access.server_state.side_effect = AssertionError('server unavailable in readback')
+ with patch.object(p, 'load', return_value=(Path(temporary), {})), patch.object(p, 'remote', return_value=dict(read_only=True, id='fixture', phase_receipts={})) as remote, contextlib.redirect_stdout(io.StringIO()):
+ p.finish(access, 'fixture', read_only=True)
+ remote.assert_called_once_with(access, {}, 'readback')
+ self.assertFalse(access.server_state.called)
+
+
+if __name__ == '__main__': unittest.main()
diff --git a/docs/windows-dev-access-recovery.md b/docs/windows-dev-access-recovery.md
new file mode 100644
index 0000000..373d4cc
--- /dev/null
+++ b/docs/windows-dev-access-recovery.md
@@ -0,0 +1,262 @@
+# Windows-Entwicklungszugang: Ablauf und vorbereitete Konsolenwiederherstellung
+
+Stand: 2026-11-14. Der bisherige SSH-Entwicklungszugang lief am
+**2026-11-14T12:55:31.254999+00:00** ab. Die vorher vorbereitete automatische
+Verlängerung wurde **nicht betreten**: kein Server- oder Windows-Enter, keine
+Ablaufzeitänderung und kein angelegter Renewalworker. Die drei fehlgeschlagenen
+Vorbereitungen und ihre Quellen bleiben historische Belege.
+
+**Aktueller Stand:** Die spätere User-Konsolenwiederherstellung wurde
+erfolgreich ausgeführt; Root bestätigte anschließend die tatsächliche Rückkehr
+des gepinnten SSH-Zugangs. Auch der getrennte vollständige Key-/Task-
+Erhaltungsabgleich und der lokale Accessmetadaten-CAS sind inzwischen bestanden.
+Einzelheiten stehen im neuen Abschlussabschnitt dieser Verlaufserfassung.
+
+Diese Entwicklungshilfe ist SSH-Bootstrap, keine RMM-Aktion und kein Ersatz für
+Geräte-mTLS, Tenantgrenzen, TrustedClock, signierte Grants oder die
+WebUI-Genehmigung. Das Notebook bleibt ausschließlich Entwicklungsrechner.
+
+## Tatsächliche abgebrochene Vorbereitungen
+
+| Fall unter `devstate/windows-client/dev-access-renewal/` | Tatsächliches Ergebnis |
+| --- | --- |
+| `45626a0c-edc4-4f35-9f36-921692bccbc1` | Rein lesende Windows-Vorbereitung verweigerte `Transport owner` vor dem Serveraufruf. Die zwei öffentlichen `.pub`-Dateien gehörten dem tatsächlichen lokalen Builtin-Administrator mit SID-Endung `-500`; deren bestehende öffentlichen Leserechte waren für die ursprüngliche private Dateiprüfung zu weit. Nur die separate öffentliche Metadatenprüfung wurde später präzisiert; keine ACL-Reparatur. |
+| `d40c06a4-d6d3-4dc0-9ef6-b1ef1197bcc9` | Rein lesende Windows-Vorbereitung verweigerte `VariableNotWritable`: die Hilfsvariable `$host` kollidierte mit PowerShells schreibgeschütztem `$Host`. Die Quelle wurde anschließend auf `$hostPublic` korrigiert. Keine Server- oder Windowsmutation. |
+| `6988fd11-0e0a-4fd7-878d-96b130d83aee` | Der lokale Datums-/Fristguard verweigerte nach Ablauf der alten Frist, noch vor `prepare-intent.json`. Dies war kein weiterer ausgeführter Windows-Readonly-Test. Der leere lokale Fall bleibt erhalten. |
+
+Die ersten beiden Fälle enthalten nur Vorbereitungsintent und Controllerkopie;
+keiner enthält einen Server-/Windows-Enterintent. Root bestätigte zusätzlich,
+dass kein Renewal-Enter und kein Worker ausgeführt wurden. Ablauf und Fehler
+werden nicht nachträglich als erfolgreiche Verlängerung ausgegeben.
+
+## Getrennte Wiederherstellung des bereits abgelaufenen Zugangs
+
+Die neue Quelle
+[`console_access_recovery.py`](../deploy/windows/console_access_recovery.py)
+hat SHA-256
+`703fb5e4ae04d8555bad858c5d7b2ac4880e06d6fa951010acd43f7201a58053`.
+Sie trennt den Server-CAS von der erst anschließend durch den User in der
+Windows-Administratorkonsole auszuführenden Phase. Die frühere
+[`dev_access_renewal.py`](../deploy/windows/dev_access_renewal.py) wird für den
+abgelaufenen Lease nicht umgedeutet oder erneut gestartet.
+
+Root führte ausschließlich den Serverteil im neuen Fall
+`4b6506a7-6c3e-4cca-a497-618fa8666300` aus. Dessen `server-entered.json`
+meldet `completed=true`; ein getrennt gespeicherter lesender Readback bestätigt
+dieselbe neue Autorisierungsdatei und Frist:
+
+| Bindung | Tatsächlicher Beleg |
+| --- | --- |
+| Neue feste UTC-Frist | `2026-11-15T13:05:58+00:00` |
+| `authorized_keys` nach CAS | `fef4db300dd39fba9b52428817f453451c251c7768dd2fb6a76b39dd110dbbf2` |
+| Unverändertes SSH-Profil | `932adc2ad3e88c3a47054c3d09e44024f21918cf144f0bb349bd8763e844e482` |
+| Unveränderte effektive SSH-Konfiguration | `3a345912fdd4bb9bb29628d670a8bdbdfbbc22b3e308ab56fb3bafb7bc15533a` |
+| Server-Enterbeleg | SHA `2185a88fc32db72119a584d84a46fb25cfca5f32f6e0c4ee5b7cf0728a361317` |
+| Getrennter Readback | SHA `f6e3f69a6cd4f006d00c90cadd8bfd47f94e954f1297bea5f6eecc4fd27d3787` |
+
+Der Serverteil ersetzte ausschließlich den Ablaufwert des gleichen bestehenden
+restriktiven Tunnelkeys. Keybytes und Optionen, Loopbacklistener
+`127.0.0.1:22240`, SSH-Profil, Serverhostpin und der Account
+`rmm-win-tunnel` mit Shell `/usr/sbin/nologin` blieben gebunden. Historische
+`prepared.json`/`registered.json` wurden nicht überschrieben. Dieser CAS
+veränderte weder einen Downloadlease noch die RMM-Konfiguration.
+
+## Öffentliches Paket und noch offene Userphase
+
+Unter dem privaten Consolefall liegt das **inzwischen zurückgezogene,
+historisch erhaltene** öffentliche Paket mit genau
+`Recover-ExistingDevAccess.ps1`, `public-recovery.json` und `README.txt`.
+Es enthält öffentliche Pins und feste Parameter, keine privaten Schlüssel oder
+Tokens. Die Paketdateien sind zusätzlich im unveränderlichen Intent gebunden.
+
+| Datei | SHA-256 |
+| --- | --- |
+| `windows-dev-access-recovery.zip` | `7bf4f7bb8336fb50852f72eec2f3e370e96cb7009b14ee15aa7232c025a38ed7` |
+| `Recover-ExistingDevAccess.ps1` | `564da57d70ef06df7bd9adc37565b7e28ef446a6c69b984711c5b77b28441e8a` |
+| Consoleintent | `cd827d4056fb0045f23bff1fd9bd21b6137b53f063fe8215ad0945c2013cc44a` |
+
+Vor der Userausführung fand Root im Konsolenguard eine unbelegte
+Ganzsekundenannahme für den alten `AccountExpires`-Wert. Der feste Wert
+`134391345310000000` ließ den Bruchteil `.254999` der ursprünglichen
+Konfigurationszeit weg. Ein lokaler .NET-Roundtrip derselben vollständigen
+UTC-Zeit ergibt `134391345312549990`. Dieser lokale Roundtrip allein war ein
+**abgeleiteter Sollwert**, noch kein gemessener Windows-VM-Accountwert. Der
+spätere tatsächliche Userreadback ist unten getrennt dokumentiert. Das alte Paket wird deshalb nicht zur
+Ausführung weitergegeben; sein gültiger getrennter Server-CAS bleibt erhalten.
+
+Die kleine neue Quelle
+[`console_access_precision.py`](../deploy/windows/console_access_precision.py)
+mit SHA
+`8b4d14edf0794c4ef662d7587b4538f8e7aebc06c11db76c3cafc2c24c11a37b`
+erzeugte den neuen lokalen Consolefall
+`5c96d3d8-1657-40c8-a6ec-c00b63a98210`. Sie bindet den ursprünglichen
+Serverintent, Enterbeleg und getrennten Readback des Falls `4b6506…` sowie
+sämtliche alten Paketdateihashes. Es gibt weder einen Serveraufruf noch eine
+erneute Fristverlängerung: `2026-11-15T13:05:58+00:00` bleibt unverändert.
+
+Der neue Guard berechnet genau einen erwarteten 64-Bit-Wert über
+`[DateTimeOffset]::Parse($cfg.expires_at).UtcDateTime.ToFileTimeUtc()` aus der
+zuvor anhand der Originalbytes und der exakten alten Zeit geprüften Config.
+Keine Rundung, Toleranz oder alternative Zeit wird akzeptiert. UUID und
+Provenienzbeleg sind neu; die drei Mutationsschritte ab `File.Replace` bis
+zum Ende sind gegenüber dem alten Paket bytegleich. Falls ein früheres Paket
+entgegen dem bisherigen Kontrollstand bereits erfolgreich ausgeführt wurde,
+muss der alte Config-Hashguard verweigern. Dann nur lesen und durch Root
+abgleichen, kein neuer Versuch.
+
+| Neues Korrekturartefakt | SHA-256 |
+| --- | --- |
+| ZIP im Fall `5c96d3d8…` | `dbcd5ca863c0b09f89b67eb10eeaeaf89b941bbc5840079f1bb0c36dc6ff3b3e` |
+| Neues `Recover-ExistingDevAccess.ps1` | `4977665fb092723998473f1c4be6685b1d93975176f8957bc3287d7e2f61cb69` |
+| Neuer unveränderlicher Intent | `eae7995b5735bf1e8f0fafc0ae6ccf6bdd4576566663c1256a511f6c3408e32e` |
+
+Die Userphase mit dem Konsolenskript des Falls `5c96…` wurde inzwischen begonnen,
+scheiterte aber vor jeder Wirkung an `Get-History / IdCannotConvert`: PowerShells
+standardmäßiger Alias `h` wird auch unter `-NoProfile` vor der Funktion `H`
+aufgelöst. Der Fehler trat im ersten Case-/Configguard vor `New-Item` auf.
+Es wurde damit keine Konfigurations-/Accountablaufzeit geändert und kein
+Tunneltask gestartet. Die unveränderte Case-Abwesenheitsprüfung bleibt für die
+erste tatsächlich noch unerreichte Wirkung verbindlich.
+
+Die separate lokale Quelle
+[`console_access_hash_command.py`](../deploy/windows/console_access_hash_command.py)
+hat SHA `b682ced57bf7ac71c0b1ba67eb5a51a20dde814fe361e1ae2cc17872147444ad`.
+Sie erzeugt `Recover-ExistingDevAccess-HashFix.ps1` mit SHA
+`d366ae1705dac3252726dedf369c04462e42534ddcf6e15dc27bba8583427d2c`.
+Ausschließlich die eine Funktionsdefinition und alle fünf Aufrufe heißen nun
+`Get-RmmRecoveryFileSha256`; eine inverse Ersetzung ergibt exakt die alten
+PS1-Bytes. Alle übrigen Guards, Pins, Fristen, die gleiche Console-UUID und
+Mutationsschritte bleiben erhalten. Kein Alias wird entfernt oder geändert.
+
+Der kleine Userpatch `Create-VerifiedHashFix.ps1` mit SHA
+`385a388476cef0c85f02bca236ade48f28a041476330d3e309ab1ca2f22bb9f5`
+prüft zuerst den ursprünglichen PS1-Hash `4977665f…`, erzeugt ausschließlich
+eine zuvor fehlende neue Datei mit UTF-8 ohne BOM, verlangt deren vollständigen
+Hash `d366ae17…` und startet erst dann den separaten Bootstrapprozess mit
+`-NoProfile -ExecutionPolicy RemoteSigned`. Kein neuer Download ist für diese
+lokale Korrektur erforderlich. Bereits vorhandene Korrekturdateien werden
+nicht überschrieben und eine unklare frühere Wirkung wird nicht wiederholt.
+
+ASTs, vollständige Command-AST-Ersetzung sowie ein tatsächlicher lokaler
+Hashfunktionsaufruf bei unverändert vorhandenem Alias `h=Get-History` bestanden;
+der unabhängige Review bestätigte die reine Namensänderung. Das sind lokale
+PowerShellprüfungen, kein weiterer Windows-VM-Erfolgsnachweis. Alte Quellen,
+ZIPs und Fehlerbelege bleiben unverändert.
+
+Die anschließende tatsächliche Userausführung des HashFix-Skripts `d366ae17…`
+verweigerte im kombinierten anfänglichen Case-/Config-/Bootstrapguard weiterhin
+vor Wirkung. Root ließ zunächst ausschließlich fünf Werte lesend ausgeben.
+Der Userreadback ergab:
+
+| Tatsächlicher Konsolenwert | Ergebnis |
+| --- | --- |
+| Recoverycase vorhanden | `false` |
+| Config-SHA | `4ad28ec55027718a4e384c79ff7cc15ec9c798411a991a5d479e960310ed6823` |
+| Bootstrap-SHA | `332ceeedf49f597eac353e0ef1f6e614c85cef20a5a20cce68d947085aa9d50f` |
+| Configablaufzeit | `2026-11-14T12:55:31.254999+00:00` |
+| Tatsächliches Account-FILETIME | `134391345312549990` |
+
+Damit ist dieser Guardfehler konkret erklärt: die Recoveryquelle erwartete
+den späteren Repositoryhash `9e992602…`, obwohl die VM exakt das ursprünglich
+veröffentlichte Bootstrap mit Hash `332ceeed…` behielt. Das erhaltene Original-ZIP
+`cba15946…` enthält genau diese Datei und die Config `4ad28ec5…`; das ebenfalls
+veröffentlichte Reparaturpaket `2558448b…` bindet denselben Bootstraphash als
+Voraussetzung und ersetzt Bootstrap/Config nicht. Der Maintainerteil beider
+Bootstrapquellen ist bytegleich. Es wird somit keine unbekannte Datei anhand
+eines beliebigen neuen Readbacks übernommen.
+
+Die getrennte lokale Quelle
+[`console_access_original_bootstrap.py`](../deploy/windows/console_access_original_bootstrap.py)
+mit SHA `c0816055407c17af4c0bf4b5bd5ce3055e5a9d44fe7f2334f5aa7913520478c6`
+bindet den tatsächlichen Userreadback und beide publizierten Originalpakete.
+Sie erzeugt `Recover-ExistingDevAccess-OriginalBootstrap.ps1` mit SHA
+`aba0a5a4152347e639266e95a05eae4343a99be9070a94fa4fc6501bfc3283d2`.
+Ausschließlich die eine Bootstrap-Sollhashkonstante wird von `9e992602…` auf
+das bestätigte Original `332ceeed…` berichtigt. Alle anderen Bytes des
+`d366ae17…`-Skripts, einschließlich gleicher Case-Abwesenheit, voller UTC-
+Präzision, Aliasfix, Fristen und Wirkungsschritte, bleiben identisch.
+
+Der Userpatch `Create-VerifiedOriginalBootstrapFix.ps1` hat SHA
+`64f1d62ea3a87d4db7103ca01f7d735689caf54a7cc4b2458908956624062549`.
+Er verlangt den vollständigen Eingabehash `d366ae17…`, schreibt nur eine
+zuvor fehlende neue Datei, prüft deren vollständigen Hash `aba0a5a4…` und
+startet erst danach den separaten Bootstrapprozess. Lokaler Python-/AST-Test,
+ein tatsächlicher lokaler PowerShelllauf des Patchpräfixes ohne Kindstart und
+der unabhängige byteweise Review bestanden. Dadurch wird die Userausführung
+der korrigierten Wirkung noch nicht vorweggenommen. Kein Serveraufruf und keine
+weitere Serverfriständerung wurden durch diese lokale Korrektur ausgeführt.
+
+Eine erfolgreiche Windows-Konsolenphase und Tunnelwiederkehr sind **noch nicht
+nachgewiesen**. Die korrigierte Strecke prüft die alten
+Config-/Bootstrapbytes und öffentlichen Pins, den bestehenden Account sowie den
+unveränderten SYSTEM-Tunneltask. Erst bei `Ready` und ohne verbliebenen
+Maintainer/SSH-Kindprozess darf sie die vorhandene Konfigurations- und
+Accountablaufzeit erneuern und den Originaltask mit dauerhaftem Startintent
+**einmal** starten. Private Keydateien werden nur über Metadaten beobachtet,
+nicht inhaltlich gelesen. Keine Installation, ACL-Reparatur, neue Schlüssel,
+zusätzlichen SSH-Rechte, Prozesskills, Reboots oder RMM-Wirkungen.
+
+Die README verlangt den unabhängig mitgeteilten Downloadhash und den festen
+PS1-Hash. Ein etwaiges `Unblock-File` betrifft nur diese exakt geprüfte
+Download-Datei; `RemoteSigned` nur den separaten Bootstrapprozess. Eine
+verweigernde GPO oder ein fehlgeschlagener Guard wird nicht umgangen. Ein
+bereits vorhandener Recoveryfall bleibt zur lesenden Inspektion erhalten.
+
+Eine gesonderte, auf 45 Minuten begrenzte Veröffentlichung über den vorhandenen
+öffentlichen TLS-Bootstrapdienst wird durch Root separat behandelt. Dieser
+Server-CAS und diese Dokumentation belegen noch keine Downloadveröffentlichung.
+Nach der Userausführung bleiben tatsächliche Tunnelwiederkehr, ursprüngliche
+SSH-Hostidentität, erhaltene Schlüssel/Taskdefinition und die lokale
+Accessmetadatenfortschreibung durch Root zu prüfen. **Neuer Windowszugriff ist
+bis dahin nicht nachgewiesen.**
+
+Lokale Python-/AST- und Paketprüfungen sowie unabhängige Source-Reviews bestanden.
+Der lokale Paketfixture verwendete einen gemockten Serveraufruf und ist kein
+zusätzlicher nativer Recoverybeleg. Kein RMM-Job, keine Capability oder
+Clockbereitschaft folgt aus der Zugangswiederherstellung.
+
+## Update: User-Konsolenerfolg und tatsächlicher gepinnter SSH-Kontakt
+
+Der User meldete die erfolgreiche Ausführung der korrigierten Konsolenstrecke
+`Recover-ExistingDevAccess-OriginalBootstrap.ps1` mit Hash `aba0a5a4…`.
+Root erhielt danach über den bereits gepinnten SSH-Zugang tatsächlich eine
+getrennte rein lesende Antwort. Der lokale Verifikationsfall ist
+`fc7a6ad5-5ec5-4280-b629-851aad2529b2`; sein `readback.json` hat SHA
+`bb0e2b4747068433bcb7c950743ef56007f22206ca5d4b458f6b8221a4a031e2`.
+Der Beleg nennt weiterhin den ursprünglichen Consolefall
+`5c96d3d8-1657-40c8-a6ec-c00b63a98210`, `read_only=true`,
+`completed=true` und `no_jobs=true`.
+
+| Tatsächlich beobachteter Wert | Ergebnis |
+| --- | --- |
+| Configablaufzeit | `2026-11-15T13:05:58+00:00` |
+| Accountablaufzeit als FILETIME | `134392215580000000` |
+| Originaler Reverse-Tunneltask | `Running` |
+| `RmmDiscoveryWindows` | `Running`, PID `3172`, `NT AUTHORITY\LocalService`, Startart `Auto` |
+| `RmmDiscoverySystemHelper` | `Stopped`, PID `0`, `LocalSystem`, Startart `Manual` |
+| `W32Time` | `Running`, PID `3488`, `NT AUTHORITY\LocalService`, Startart `Manual` |
+
+Damit ist die Rückkehr des Entwicklungszugangs belegt. Die früheren Aussagen
+zur noch offenen Userphase bleiben historische Zwischenstände. Der zusätzliche
+rein lesende Erhaltungsbeleg desselben Falls (`preservation.json`, SHA256
+`490e01809ca1e4225f1dbb6a0a4414cf77f7822be31233366480b3a0d4810592`)
+bestätigt alle sechs festen öffentlichen Dateien samt SHA/SDDL, Metadaten und
+SDDL der vier privaten SSH-Schlüssel ohne Lesen ihrer Inhalte, den exakten
+Originaltask-XML-Hash und Runningzustand, Account-SID sowie alle öffentlichen
+Pins. Danach wurde lokal ausschließlich die Frist im Accessmetadaten-JSON per
+CAS auf `2026-11-15T13:05:58+00:00` fortgeschrieben. Der SSH-Präfix blieb exakt
+erhalten; Original und neuer Metadatenbeleg sind privat archiviert. Die alten
+Fehlerfälle, Pakete und Korrekturquellen bleiben erhalten.
+
+Der Readback ist kein Paarupgrade-, TrustedClock-, Boot- oder RMM-Jobnachweis.
+Insbesondere eröffnet `W32Time=Running` keine Clockbereitschaft. Der Helper
+war tatsächlich noch gestoppt; daraus wird kein authentisierter neuer
+Agent-/Helper-Pipeaustausch abgeleitet. Root führt die getrennten Pipe-/MIDL-
+Prüfungen erst anschließend fort.
+
+Der User hat den nächsten Arbeitsfokus ausdrücklich auf die Skriptkonsole mit
+vollständigem Shell-/PowerShellinhalt, tatsächlicher WebUI-Plangenehmigung,
+Ausgabe und expliziten Root-/SYSTEM-Ausführungsrechten gelegt. Paketabnahmen
+sind nachgeordnet. Der erneuerte SSH-Bootstrapzugang verleiht selbst keine
+RMM-Ausführungsrechte und ersetzt keine dieser noch separat nachzuweisenden
+Genehmigungs- und Ausführungsgrenzen.
diff --git a/docs/windows-system-pipe-drain.md b/docs/windows-system-pipe-drain.md
new file mode 100644
index 0000000..d5c315a
--- /dev/null
+++ b/docs/windows-system-pipe-drain.md
@@ -0,0 +1,53 @@
+# Windows-Pipe v2: tatsächlicher Unitnachweis
+
+Dieser Ergebnisnachtrag ergänzt den unveränderten, im Buildmanifest gebundenen
+[Framing-/Drain-Entwurf](windows-helper-pipe-drain.md). Der Entwurf bleibt als
+historischer Quellenstand erhalten; dieser Nachtrag verändert weder seinen Hash
+noch das ursprüngliche Manifest.
+
+## Tatsächlich auf Windows bestanden
+
+Root führte im eigenen nativen Fall
+`db25cd4a-bfd2-45d5-9f80-1881950853f7` die beiden konkreten Testprogramme des
+Pipe-v2-Packs aus. Beide vollständigen nativen Listen wurden vor irgendeinem
+Unitfall exakt geprüft. Alle23 Libraryfälle und alle7 Binaryfälle bestanden;
+kein Fall war fehlgeschlagen, ignoriert oder gefiltert. Beide Listenprozesse
+und beide Testprozesse endeten mit Exit0 ohne Timeout. Die gemeldete Testdauer
+betrug2,76s für die Library und0,07s für das Binary.
+
+| Gebundener Beleg | SHA256 |
+| --- | --- |
+| Neues Pipe-v2-Buildmanifest | `b2f77713a4f70deddb6472fb1e869a85443ce1028914f62ccee71f8001fbadb4` |
+| Tatsächlicher Native-PASS | `19a8ccd95b7225f7e8657a696055bea4b52ed2f80f6caa3f42c9396ce6272713` |
+| Begrenzter Unitrunner | `2ac6bd55e608e7dbb0f0cf65cf37e7bbccc42b862d09c50b37e9162f29f4bbdf` |
+| Library-Lieferdatei | `3fc2b7314d755f5c5235c8383cf605cbe848180180497bb30540482f4910c2a1` |
+| Binary-Lieferdatei | `a3b8f44e87df7af54f82c1d052753217e9a03c495fb28c8a16ba9fe7e1a0af23` |
+
+Geschützter nativer Beleg im isolierten Pipeworktree:
+`devstate/windows-client/native-pipe-v2/db25cd4a-bfd2-45d5-9f80-1881950853f7/passed.json`.
+Das zugehörige unveränderliche Buildmanifest liegt unter
+`devstate/windows-pipe-drain-build/build-59623db2-15ca-40cd-8728-861f84b2a550/manifest.json`.
+Die vorherige Manifestgeneration `928841e7…`, ihre Links und sämtliche früheren
+Belege bleiben erhalten.
+
+## Was dieser PASS belegt
+
+Die vorhandenen IPC-Codec-/Sicherheits-/Journal-/Runtimefälle liefen tatsächlich
+auf Windows als Bootstrapadministrator. Der Beleg weist `no_jobs=true` aus.
+Der Unitrunner begrenzt nach einem Timeout die Wartezeit auf das eigene
+Testprozessende und auf beide Ausgabe-Tasks; eine verlorene Antwort erlaubt nur
+den create-only gespeicherten Fall zu lesen. Das ist keine Änderung des
+Produktjob- oder Installerabbruchs.
+
+`local_service_proof`, `native_pipe_proof` und `clock_adapter_qualified` sind im
+Native-PASS ausdrücklich weiterhin `false`. Dieser Unitlauf ist kein
+Produkt-LocalService-zu-SYSTEM-Austausch, kein Nachweis, dass Drain v2 die zuvor
+beobachtete233-Störung tatsächlich behebt, und keine SYSTEM-/Clock-/Jobfreigabe.
+Der bestehende rohe V1-Control ist kein V2-Peernegativnachweis.
+
+Der erhaltende Paarupgrade, die Bindung an den nach dem Konsolenneustart
+vorhandenen tatsächlichen Prozesskontext und der anschließende reale
+Agent/Helper-Austausch bleiben gesondert zu prüfen. Vor dessen Ausführung stehen
+noch der unabhängige fokussierte Quellreview des neuen Upgrade-Runners und die
+explizite Root-Zielaktion. Keine Paket-, SCM-Fixture-, Reboot- oder sonstige
+RMM-Wirkung folgt aus dieser Unitabnahme.
diff --git a/docs/windows-system-pipe-upgrade.md b/docs/windows-system-pipe-upgrade.md
new file mode 100644
index 0000000..ca3207f
--- /dev/null
+++ b/docs/windows-system-pipe-upgrade.md
@@ -0,0 +1,148 @@
+# Windows Pipe-v2: erhaltender Paarupgrade nativ bestanden
+
+Stand: 2026-11-14. Paarupgrade und tatsächlicher authentisierter Austausch des
+laufenden LocalService-Agenten mit seinem SYSTEM-Helper sind bestanden.
+Die ursprünglichen Vorbereitungsabschnitte unten bleiben Verlauf. RMM-Jobs,
+TrustedClock und Helperwirkungen bleiben weiterhin gesperrt.
+
+Die ursprüngliche quellengebundene
+[Framingdokumentation](windows-helper-pipe-drain.md) bleibt unverändert. Diese
+separate Datei beschreibt ausschließlich die späteren Upgradevorbereitungen.
+Der Notebookhost bleibt reiner Entwicklungsrechner; Ziel ist die eigene
+Windows-VM am endgültigen Cloudserver.
+
+## Geprüfter Kandidat und begrenzter Bootstrapvertrag
+
+Der neue Runner
+[`system_pipe_upgrade.py`](../deploy/windows/system_pipe_upgrade.py) ist mit
+SHA `e466576673a0e5c332cfc1613ae88a62f5b526015ced76b1d22473e292a995e0`
+eingefroren. Sein frischer isolierter Prüfer bindet den neuen Pipe-Packtyp und
+dessen Originalquellen, genaue native Listen mit **23 Library- und 7
+Binarytests** sowie die erhaltenen Linux-first-Corebelege mit 80 Linux- und
+58 Windowsfällen. Es gibt keine Umbenennung alter Delegationsmanifeste und
+keine Umleitung des eigenen Source-Roots auf Main.
+
+Der gebundene Pipe-Pack hat Manifest-SHA
+`b2f77713a4f70deddb6472fb1e869a85443ce1028914f62ccee71f8001fbadb4`.
+Die tatsächlichen 23+7 Windows-Administratorunits bestanden im Fall
+`db25cd4a-bfd2-45d5-9f80-1881950853f7`; dessen `passed.json` hat SHA
+`19a8ccd95b7225f7e8657a696055bea4b52ed2f80f6caa3f42c9396ce6272713`.
+Das sind Unitnachweise, kein LocalService-/Pipe-/Clock-Erfolgsbeleg.
+
+Die vorbereitete Mutation verlangt eine separat geprüfte frische Baseline mit
+SCM-/Kernel-PID und tatsächlicher Prozessgeburt, Konto, aktivem Service-SID,
+Imagehash und ACLs. Ein bereits gestoppter Manual-Helper erhält keinen
+Vorabstart. Vor der ersten Ersetzung werden vier private Sicherungen erstellt;
+jede Ersetzung verlangt zusätzlich einen eigenen zuvor fehlenden nativen
+Backupnamen und frische Datei-ID-/Hash-/ACL-CAS-Prüfungen. Beide Dienste bleiben
+bis zur vollständigen neuen EXE-/Policy-/Pingeneration gestoppt. Danach sind
+Helper- und Agentstart jeweils create-once. Config-/CA-/Identitäts-/Zertifikats-
+und Private-Key-Metadaten samt Datei-IDs werden auch nach den Ersetzungen,
+vor dem Start und beim Finish unverändert verlangt.
+
+`readback` ist rein lesend und kann auch einen fehlenden Zielpfad sowie einen
+SCM-Pendingzustand ehrlich zeigen. Baseline, Enter und Finish behalten ihre
+strengen Identitätsprüfungen. Nach verlorener Mutationsantwort gibt es keinen
+automatischen Enter-/Start-/Rollbackretry. Ein Finish benötigt neue passive
+Heartbeats und konkrete Inventar-ACKs; es schreibt nur einen lokalen Beleg.
+Main-Indizes werden ausschließlich durch Root separat per CAS fortgeschrieben.
+
+## Tatsächlicher Fall 14fb: Timeout und geprüfte erste Fortsetzung
+
+Fallverzeichnis:
+`devstate/windows-client/system-pipe-upgrade/14fb176a-f653-4573-a8d7-6f9fe47a3020/`.
+Der erste `prepare`-Aufruf begann am `2026-11-14T12:39:48.414511+00:00`
+und endete nach 180 Sekunden mit `TimeoutExpired` während des ersten
+Stagingaufrufs. Zu diesem Zeitpunkt gab es lokal nur den Prepareintent und
+Quellkopien, keine Baseline und keinen Enterintent. Die genaue Ursache des
+SSH-/Bootstraptimeouts ist nicht nachgewiesen.
+
+Ein danach gesondert ausgeführter lesender Check bestätigte: beide neuen
+EXE-Stagingverzeichnisse, der neue entfernte Komponentenfall und der neue
+Active-Marker waren noch nicht vorhanden. Der alte Agent lief, der alte Helper
+war gestoppt. Auf dieser Abwesenheit beruhte die explizite create-once
+Fortsetzung der tatsächlich noch unerreichten Vorbereitungsphase im selben
+Fall; kein neuer Upgradefall und kein wiederholtes Enter.
+
+| Erhaltener Beleg | SHA-256 |
+| --- | --- |
+| `prepare-first-stage-timeout.json` | `535faf7c6c4c7b3dba1f8d7b7889bc59acdee09fd51c2830fe397c3c9076f1e9` |
+| `first-prepare-readonly-absence.json` | `983b38fcc2cdc8e907436eb3053f32ad2cd131e765a82dd1e9930346e1c6877b` |
+| Private Fortsetzungsquelle `continue-first-prepare.py` | `86453aef4a1d59f73e423993b548e58ad0541205961a5952c80807403881cf3b` |
+| `continue-first-prepare-intent.json` | `7420622b7866e7b43b34087d5334599444a046b95a89e7f48503aca0f4e03be0` |
+| Neue lesende `baseline.json` | `57b79e9c918df6165cac0bb451b33fcd0c207933f15351afcd2ad6c400f4e2d7` |
+
+Die Fortsetzung erzeugte schließlich den Baseline-/Intentbeleg und die
+serverseitigen Vorherbeobachtungen. Das ursprüngliche Timeout und seine
+Abwesenheitsmessung wurden nicht überschrieben.
+
+## Baseline und verbleibende tatsächliche Abnahme
+
+Die frische Baseline zeigt den weiterhin vorhandenen Agenten `89004ad3…`
+unter LocalService (`S-1-5-19`), `Running/Auto`, PID `3172`, mit exakter
+Kernel-FILETIME `134391328200102621`. Der vorhandene Helper `e6aacbdd…`
+ist `Stopped/Manual`, PID `0`; dafür wird kein laufender Prozess behauptet.
+Policy `007adf5f…` und Pin `126670bc…` gehören weiterhin zur alten Generation.
+Die Telemetriedatenbank wurde lesend mit `integrity=ok`, Sequenz `2564` und
+`pending_inventory_events=0` beobachtet. Ursprüngliche PKI-/DB-/Lock-Datei-IDs,
+ACLs und die beiden uninitialisierten Nullbyte-Intentleaves sind im privaten
+Baselinebeleg gebunden.
+
+Vorherige Serverzählungen blieben:
+Windows `jobs/outbox/permits/unresolved = 0/0/0/0`, Linux
+`30/30/26/0`. Die beobachteten API-/Gateway-Transportfaultflags waren geschlossen;
+dies ist eine konkrete Vorhermessung, kein künftiger Nachherbeleg.
+
+Der vorbereitete Kandidat umfasst Agent `f10c78dd…`, Helper `5f8c62fa…`,
+Policy `a3024467…` und Pin `af518db8…`. **Es existiert für diesen Fall noch kein
+Enterintent oder tatsächlicher Stop-/Swap-/Start-/Finishbeleg.** Staging ist
+keine Installation oder laufende Nutzung der neuen EXEs. Der alte SSH-Zugang
+lief anschließend aus; seine getrennte
+[Konsolenwiederherstellung](windows-dev-access-recovery.md) ist eine notwendige
+Zugangsstrecke und kein Paarupgrade.
+
+Nach tatsächlicher Wiederherstellung des Zugangs muss Root die Baseline vor
+Mutation erneut bewerten. Geänderte PID/Birth-, Datei-, Index- oder andere
+gebundene Werte dürfen nicht still übernommen werden. Erst danach können der
+einmalige erhaltende Paarupgrade, zwei neue tatsächliche WSS-Heartbeats,
+Inventar-ACK, Tenantverweigerung und unveränderte Job-/Policygrenzen geprüft
+werden. Ein tatsächlicher authentisierter Austausch des laufenden
+LocalService-Agenten mit dem neuen SYSTEM-Helper bleibt offen. Jobfreigabe,
+Helperwirkungen und Clockqualifikation bleiben geschlossen.
+
+## Tatsächlicher Abschluss im selben Fall
+
+Nach der getrennt verifizierten SSH-Zugangswiederherstellung wurde derselbe
+Fall14fb genau einmal betreten. Die frische CAS-Prüfung bestätigte vor der
+Mutation die unveränderte ursprüngliche Baseline, beide lokalen Runtimeindizes
+und die geschlossenen Serverzähler/Policies. Der bereits gestoppte Helper
+wurde nicht vorab gestartet. Beide Dienste blieben während aller vier
+Dateiersetzungen gestoppt; Originale und native Backups sind erhalten.
+
+Das anschließende rein lesende Finish bestätigt:
+
+- Agent `f10c78dd738e7fb277e0c4d24fadf0f61ae3269458399b9224570ba5e66abc2c`
+ läuft als LocalService/Auto, PID5528, Geburt `134391415551175930`.
+- Helper `5f8c62fab6bc8ea1bbb009166b3d0e741c034c36690a4e32ea4e3cb2d7729a79`
+ läuft als SYSTEM/Manual, PID9464, Geburt `134391415512591188`.
+- Tatsächliche Agentprobe: `authenticated_pipe_exchange=true` und
+ `client_service_pid_verified_by_helper=true`; Helperkonto/Service-SID und
+ feste EXE-/Policybindungen geprüft. Der frühere Win32233-Lauf bleibt
+ fehlgeschlagen; daraus wird keine rückwirkend bewiesene Fehlerursache.
+- Zwei neue WSS-Heartbeats, ursprüngliche mTLS-Geräteidentität,
+ Inventar-ACK/Sequenz2813 und Tenantverweigerung bestätigt. Agent-/Helper-
+ DB-/Lock-/PKI-Datei-IDs, Historie und leere Intentleaves erhalten.
+- Windows0/0/0/0, Linux30/30/26/0, geschlossene Testflags/Policies,
+ `helper_ready=false`, `helper_clock_qualified=false`, keine SYSTEMcapability
+ und keine Jobs oder Wirkung. Private Schlüssel wurden nicht gelesen.
+
+Originaler `result.json`-SHA256:
+`d5c4996821911a5bdac5014e9f985c56bbb592b803f2e33411dd28bb986b8eed`.
+Er wurde samt Intent/Baseline bytegleich im privaten Main-Evidenzpfad
+archiviert. Erst danach veröffentlichte Root lokal beide Indizes per CAS unter
+einem gemeinsamen Lock, mit erhaltenen Vorgängerdateien und eigener
+Publikationsreceipt. Keine erneute Zielmutation:
+Runtimeindex `e49231e72aff7b001189b8507200c6c701f73e47f77c29194116cf1da41ca0c2`,
+Komponentenindex `005317e652f50de3e1277be3bc42717318226208015e7c8011e1b73469cc7562`.
+Der Nachweis qualifiziert den Pipe-v2-Peertransport und die passive Erhaltung,
+keine Clock, SYSTEM-Skriptkonsole oder Paketwirkung.