The ultimate harness for coding agents and beyond. All your agents. All your machines. One command center. Start with code, then follow your curiosity and build across disciplines: CAD, circuits, robots, games and music.
TypeScript 3d-modelingagent-frameworkagent-harnessai-agentscadclaude-codecodexcoding-agentsdeveloper-toolsesp32game-developmentmcp-servermulti-agentopen-hardwareopencodeopenharnesspcbroboticsterminaltmux
fix(os): target the active updater instead of a named tab (#820)
Dee0de712afa23c
diff --git a/.github/workflows/os-input.yml b/.github/workflows/os-input.ymlindex 3add318db..bd8b241a4 100644--- a/.github/workflows/os-input.yml+++ b/.github/workflows/os-input.yml@@ -9,9 +9,9 @@ on:default: '37222390225'required: trueprobe:- description: 'Laptop controls, Apple boot modules or unsupported-platform install refusal'+ description: 'Laptop controls, Apple boot modules, install refusal or updater pane ownership'type: choice- options: [laptop-input, apple-boot, install-preflight]+ options: [laptop-input, apple-boot, install-preflight, update-pane, update-context]default: laptop-inputrequired: truepush:@@ -42,7 +42,9 @@ jobs:env:PROBE: ${{ inputs.probe }}run: |- if [[ "$PROBE" == install-preflight ]]; then+ if [[ "$PROBE" == update-pane || "$PROBE" == update-context ]]; then+ python3 -m py_compile os/tests/update_pane_vm.py os/tests/update_pane_guest.py os/tests/update_context_vm.py os/live_update.py os/root/usr/lib/harness-os/open-updates+ elif [[ "$PROBE" == install-preflight ]]; thenPYTHONPATH=os/tests python3 -m unittest test_hardware test_installerpython3 -m py_compile os/tests/platform_preflight_vm.py os/tests/platform_preflight_guest.pypython3 os/tools/check.py@@ -54,7 +56,7 @@ jobs:sudo apt-get install -y --no-install-recommends qemu-system-x86 qemu-utils ovmf python3-pil tesseract-ocrsudo chmod a+rw /dev/kvm- name: Check actual media-key input on USB and installed sessions- if: ${{ inputs.probe != 'apple-boot' && inputs.probe != 'install-preflight' }}+ if: ${{ inputs.probe == 'laptop-input' || !inputs.probe }}run: python3 os/tests/input_vm.py --iso os/dist/*.iso- name: Check Apple initramfs selection and encrypted bootif: ${{ inputs.probe == 'apple-boot' }}@@ -62,6 +64,12 @@ jobs:- name: Check unsupported-platform refusal without disk writesif: ${{ inputs.probe == 'install-preflight' }}run: python3 os/tests/platform_preflight_vm.py --iso os/dist/*.iso+ - name: Check actual updater pane ownership and closing handoff+ if: ${{ inputs.probe == 'update-pane' }}+ run: python3 os/tests/update_pane_vm.py --iso os/dist/*.iso+ - name: Observe shipped updater pane identity interfaces without installing+ if: ${{ inputs.probe == 'update-context' }}+ run: python3 os/tests/update_context_vm.py --iso os/dist/*.iso- name: Retain actual input, module and display evidenceif: always()uses: actions/upload-artifact@v6@@ -71,11 +79,17 @@ jobs:os/test-results/input/os/test-results/apple-boot/os/test-results/install-preflight/+ os/test-results/update-pane/+ os/test-results/update-context/!os/test-results/input/*.qcow2!os/test-results/input/OVMF_VARS.fd!os/test-results/apple-boot/*.qcow2!os/test-results/apple-boot/OVMF_VARS.fd!os/test-results/install-preflight/*.qcow2!os/test-results/install-preflight/OVMF_VARS.fd+ !os/test-results/update-pane/*.qcow2+ !os/test-results/update-pane/OVMF_VARS.fd+ !os/test-results/update-context/*.qcow2+ !os/test-results/update-context/OVMF_VARS.fdretention-days: 14compression-level: 0diff --git a/os/README.md b/os/README.mdindex b7d47a072..2ed4a5e37 100644--- a/os/README.md+++ b/os/README.md@@ -205,7 +205,7 @@ is always deliberate. After that reboot, the same update request finishes anyremaining hn/CLI release against the new OS base. Later background checks returnto downloading only. See [update development](DEVELOPMENT.md#fast-hn-updates).-Earlier previews retain their existing controls until this update is installed:+Previews 5 through 11 retain their existing controls until this update is installed:**Super+u**, then **s**, then the account password. No new USB flash is needed.Preview 4 needs the matching bootstrap bundle from thediff --git a/os/live_update.py b/os/live_update.pyindex 720cc077e..c4df8bde1 100644--- a/os/live_update.py+++ b/os/live_update.py@@ -38,6 +38,7 @@ DOWNLOAD_CHUNK = 1024 * 1024RESTART_REQUIRED = Path('/run/harness-os-restart-required')SYSTEM_LOCK = Path('/run/lock/hn-os.lock')BOOT_ID = Path('/proc/sys/kernel/random/boot_id')+PROC = Path('/proc')WORDMARK = ('█ █ ▄▀█ █▀█ █▄ █ █▀▀ █▀ █▀', '█▀█ █▀█ █▀▄ █ ▀█ ██▄ ▄█ ▄█')@@ -78,6 +79,59 @@ def write(path, data):temporary.unlink(missing_ok=True)+@contextmanager+def screen_registration():+ """Publish only an active Updates UI, not the rest of its process lifetime."""+ token = os.environ.get('HARNESS_UPDATE_INSTANCE', '')+ if re.fullmatch(r'[0-9a-f]{32}', token):+ (STATE / 'screens').mkdir(parents=True, exist_ok=True, mode=0o700)+ start = (PROC / str(os.getpid()) / 'stat').read_text().rsplit(')', 1)[1].split()[19]+ # Do not acquire open.lock here: the opener can be waiting for this+ # registration while serializing another simultaneous shortcut.+ write(STATE / 'screens' / str(os.getpid()), dict(+ pid=os.getpid(), start=start, token=token, boot_id=BOOT_ID.read_text().strip()))+ try:+ yield+ finally:+ unregister_screen()+++def unregister_screen():+ (STATE / 'screens' / str(os.getpid())).unlink(missing_ok=True)+++def request_for_screen():+ request = read(STATE / 'request.json', {})+ if not isinstance(request, dict) or 'requested_at' not in request:+ return False+ target = request.get('target')+ return target is None or (isinstance(target, str) and re.fullmatch(r'[0-9a-f]{32}', target) is not None+ and target == os.environ.get('HARNESS_UPDATE_INSTANCE'))+++def consume_request():+ # Match and claim together: another client must not replace the request+ # between our read and unlink. The opener uses this same handoff lock.+ with (STATE / 'open.lock').open('a') as lock:+ fcntl.flock(lock, fcntl.LOCK_EX)+ if not request_for_screen():+ return False+ (STATE / 'request.json').unlink()+ return True+++def close_screen():+ # Serialize the final close decision with Super+u's request and selection.+ # A request arriving after the last UI poll must be handled, not abandoned+ # while this Python process is still alive in curses cleanup.+ with (STATE / 'open.lock').open('a') as lock:+ fcntl.flock(lock, fcntl.LOCK_EX)+ if request_for_screen():+ return False+ unregister_screen()+ return True++@contextmanagerdef locked():STATE.mkdir(parents=True, exist_ok=True, mode=0o700)@@ -292,7 +346,7 @@ def prepared():def notice(message):- # Only OS configuration renders this option. No shared hn welcome/UI change.+ # Retained for an explicitly customized footer; the OS uses hn's standard bar.try:run('/usr/bin/hn', 'set-option', '-g', '@harness-update', message)except (OSError, subprocess.SubprocessError):@@ -625,7 +679,7 @@ def update_all():(STATE / 'approved.json').unlink(missing_ok=True)-def screen(window, message='', refresh=False):+def screen(window, message='', refresh=False, retry=False):curses.curs_set(0)window.keypad(True)window.timeout(500)@@ -699,9 +753,8 @@ def screen(window, message='', refresh=False):message = str(error)while True:choices = draw()- requested = STATE / 'request.json'- if requested.exists():- requested.unlink(missing_ok=True)+ if consume_request() or retry:+ retry = Falseif not RESTART_REQUIRED.exists():# The shortcut starts updating. A ready download needs no# further network round trip; otherwise discover it now.@@ -718,18 +771,22 @@ def screen(window, message='', refresh=False):refresh = Falsekey = window.getch()if key in (27, ord('q')):- return+ if close_screen():+ returnif key in (9, curses.KEY_BTAB, curses.KEY_LEFT, curses.KEY_RIGHT):choice = (choice + 1) % len(choices)elif key in (10, 13, curses.KEY_ENTER):- return choices[choice % len(choices)][1]+ action = choices[choice % len(choices)][1]+ if action is not None or close_screen():+ return actionelif key == curses.KEY_MOUSE:try:_, x, y, _, buttons = curses.getmouse()if buttons & (curses.BUTTON1_CLICKED | curses.BUTTON1_RELEASED):for row, left, right, action in targets:if y == row and left <= x < right:- return action+ if action is not None or close_screen():+ return actionexcept curses.error:pass@@ -743,38 +800,24 @@ def main(argv=None):parser.error('Open Updates as your normal user on an installed Harness system.')STATE.mkdir(parents=True, exist_ok=True, mode=0o700)if args.action == 'request':- write(STATE / 'request.json', {'requested_at': time.time()})+ target = os.environ.get('HARNESS_UPDATE_TARGET')+ request = {'requested_at': time.time()}+ if target is not None:+ if not re.fullmatch(r'[0-9a-f]{32}', target):+ raise ValueError('Invalid Updates screen target.')+ # Private opener handoff already holds open.lock while waiting for+ # this child. Taking it again here would deadlock startup.+ write(STATE / 'request.json', dict(request, target=target))+ else:+ with (STATE / 'open.lock').open('a') as lock:+ fcntl.flock(lock, fcntl.LOCK_EX)+ write(STATE / 'request.json', request)elif args.action == 'check':check(read(args.feeds) if args.feeds else None)finish_approved_update()elif args.action == 'screen':- message = ''- # A prepared release can be applied immediately. Otherwise check now- # instead of exposing another command or making the user wait for a timer.- refresh = not (prepared() or system_channel().get('available'))- while True:- action = curses.wrapper(screen, message, refresh)- if action is None:- break- message, refresh = '', action == 'check'- try:- if action == 'check':- # Retry means finish updating, without another confirmation- # after the connection or release has recovered.- write(STATE / 'request.json', {'requested_at': time.time()})- if action == 'reboot':- subprocess.run(['systemctl', 'reboot'], check=True)- break- if action == 'update':- print('Updating Harness… Your agents keep running.', flush=True)- update_all()- elif action == 'restore-system':- subprocess.run(['sudo', '-n', '/usr/bin/harness', 'rollback'], check=True)- (STATE / 'system.json').unlink(missing_ok=True)- (STATE / 'approved.json').unlink(missing_ok=True)- except (ValueError, OSError, subprocess.SubprocessError) as error:- write(STATE / 'error.json', {'at': time.time(), 'error': str(error)})- message = 'The update did not finish. Try again.'+ with screen_registration():+ run_screen()elif args.action in ('apply', 'rollback'):apply(rollback=args.action == 'rollback')else:@@ -784,6 +827,35 @@ def main(argv=None):'system': system_channel(), 'check': read(STATE / 'check.json')}, indent=2))+def run_screen():+ message = ''+ retry = False+ # A prepared release can be applied immediately. Otherwise check now+ # instead of exposing another command or making the user wait for a timer.+ refresh = not (prepared() or system_channel().get('available'))+ while True:+ action = curses.wrapper(screen, message, refresh, retry)+ if action is None:+ break+ message, refresh, retry = '', action == 'check', action == 'check'+ try:+ # Retry belongs to this inspection, even when a different Updates+ # screen is open. It must not broadcast an apply request there.+ if action == 'reboot':+ subprocess.run(['systemctl', 'reboot'], check=True)+ break+ if action == 'update':+ print('Updating Harness… Your agents keep running.', flush=True)+ update_all()+ elif action == 'restore-system':+ subprocess.run(['sudo', '-n', '/usr/bin/harness', 'rollback'], check=True)+ (STATE / 'system.json').unlink(missing_ok=True)+ (STATE / 'approved.json').unlink(missing_ok=True)+ except (ValueError, OSError, subprocess.SubprocessError) as error:+ write(STATE / 'error.json', {'at': time.time(), 'error': str(error)})+ message = 'The update did not finish. Try again.'++if __name__ == '__main__':try:main()diff --git a/os/root/usr/bin/harness b/os/root/usr/bin/harnessindex 9311faac2..267ce36e7 100644--- a/os/root/usr/bin/harness+++ b/os/root/usr/bin/harness@@ -28,6 +28,13 @@ if [ "${1:-}" = rollback ]; thenfiif [ "${1:-}" = updates ]; thenshift+ if [ -t 0 ] && [ -z "${SSH_CONNECTION:-}${SSH_TTY:-}" ] &&+ { [ "$#" = 0 ] || { [ "$#" = 1 ] && [ "$1" = screen ]; }; }; then+ /usr/lib/harness-os/open-updates --view+ updates_status=$?+ # No hn client (or SSH): retain the ordinary terminal inspection.+ [ "$updates_status" = 3 ] || exit "$updates_status"+ fiexec /usr/bin/python3 /usr/lib/harness-os/live_update.py "$@"fi. /usr/lib/harness-os/runtime-pathdiff --git a/os/root/usr/lib/harness-os/open-updates b/os/root/usr/lib/harness-os/open-updatesindex f828c388e..c33394156 100644--- a/os/root/usr/lib/harness-os/open-updates+++ b/os/root/usr/lib/harness-os/open-updates@@ -1,5 +1,161 @@-#!/bin/sh-# Reuse hn's existing surface, including when the browser has focus.-[ ! -f /etc/harness-live ] || exit 0-harness updates request || exit-hn select-window -t Updates 2>/dev/null || hn new-window -n Updates '/usr/bin/harness updates'+#!/usr/bin/python3+"""Open the live updater pane; its display name is not an ownership marker."""+import argparse+import fcntl+import json+import os+from pathlib import Path+import re+import secrets+import subprocess+import time++STATE = Path.home() / '.local/state/harness-os/updates'+PROC = Path('/proc')+BOOT_ID = Path('/proc/sys/kernel/random/boot_id')+UPDATER = '/usr/lib/harness-os/live_update.py'+OPTION = '@harness-update-instance'+FORMAT = '#{pane_id}\t#{pane_dead}\t#{window_id}\t#{' + OPTION + '}'+++def hn(*args, socket=None):+ target = ['-S', socket] if socket is not None else []+ return subprocess.check_output(['/usr/bin/hn', *target, *args], text=True, timeout=5).strip()+++def process(pid):+ """Read a Linux process identity without mistaking a reused PID for its owner."""+ try:+ path = PROC / str(pid)+ fields = (path / 'stat').read_text().rsplit(')', 1)[1].split()+ if path.stat().st_uid != os.getuid() or fields[0] in ('Z', 'X'):+ return None+ return {'pid': pid, 'start': fields[19], 'group': fields[2], 'foreground': fields[5]}+ except (OSError, IndexError):+ return None+++def registration(token, owner):+ try:+ record = json.loads((STATE / 'screens' / str(owner['pid'])).read_text())+ if (record['pid'] == owner['pid'] and record['start'] == owner['start']+ and record['token'] == token and record['boot_id'] == BOOT_ID.read_text().strip()):+ return record+ except (OSError, ValueError, KeyError, TypeError):+ pass+ return None+++def updater_process(token):+ # Daemon-backed panes need not expose pane_pid or HN_SOCKET, and their+ # TMUX_PANE belongs to the backend, not hn's UI namespace. The opener binds+ # a fresh token to both the actual UI pane and the active Python process.+ owners = []+ for entry in (STATE / 'screens').glob('*'):+ if not entry.name.isdigit():+ continue+ current = int(entry.name)+ before = process(current)+ if not before:+ continue+ path = PROC / str(current)+ try:+ argv = (path / 'cmdline').read_bytes().rstrip(b'\0').split(b'\0')+ env = (path / 'environ').read_bytes().split(b'\0')+ active = registration(token, before)+ if (argv in ([b'/usr/bin/python3', UPDATER.encode()],+ [b'/usr/bin/python3', UPDATER.encode(), b'screen'])+ and active+ and before['group'] == before['foreground']+ and ('HARNESS_UPDATE_INSTANCE=' + token).encode() in env+ and process(current) == before):+ owners.append(before)+ except (OSError, ValueError):+ continue+ return owners[0] if len(owners) == 1 else None+++def updater_panes(socket):+ for line in hn('list-panes', '-s', '-F', FORMAT, socket=socket).splitlines():+ parts = line.split('\t')+ if len(parts) != 4:+ continue+ pane, dead, window, token = parts+ if not (re.fullmatch(r'%\d+', pane) and dead == '0'+ and re.fullmatch(r'@\d+', window) and re.fullmatch(r'[0-9a-f]{32}', token)):+ continue+ owner = updater_process(token)+ if owner:+ yield pane, window, token, owner+++def request_update(token):+ # The caller holds open.lock until the selected UI owns this request.+ subprocess.run(['/usr/bin/harness', 'updates', 'request'],+ env=dict(os.environ, HARNESS_UPDATE_TARGET=token), check=True, timeout=5)+++def open_updates(view=False):+ if view and (os.environ.get('SSH_CONNECTION') or os.environ.get('SSH_TTY')):+ return False # Keep an SSH inspection on its own terminal.+ STATE.mkdir(parents=True, exist_ok=True, mode=0o700)+ # Serialize shortcut handoff, not downloads or activation. Waiting for a new+ # pane's actual process prevents rapid shortcuts from creating duplicate tabs.+ with (STATE / 'open.lock').open('a') as lock:+ fcntl.flock(lock, fcntl.LOCK_EX)+ try:+ socket = hn('display-message', '-p', '#{socket_path}')+ except (OSError, subprocess.SubprocessError):+ if view:+ return False+ raise+ if not socket.startswith('/'):+ if view:+ return False+ raise ValueError('Harness has no active terminal. Open a terminal and try again.')+ if view:+ # hn can answer from a headless server restored for stored sessions.+ # Its own client row is empty; do not send manual inspection into+ # an invisible pane or use another client's row via list fanout.+ try:+ client = hn('hn-list-clients', '-F', '#{client_tty}', socket=socket)+ except (OSError, subprocess.SubprocessError):+ return False+ if not client.startswith('/dev/') or '\n' in client:+ return False+ for pane, window, token, owner in updater_panes(socket):+ if not view:+ request_update(token)+ try:+ hn('select-window', '-t', window, socket=socket)+ hn('select-pane', '-t', pane, socket=socket)+ except subprocess.CalledProcessError:+ continue # The old pane can finish closing during selection.+ if (pane, window, token, owner) in updater_panes(socket):+ return True+ token = secrets.token_hex(16)+ if not view:+ request_update(token)+ pane = hn('new-window', '-P', '-F', '#{pane_id}', '-n', 'Updates',+ 'exec env HARNESS_UPDATE_INSTANCE=' + token + ' /usr/bin/python3 ' + UPDATER + ' screen', socket=socket)+ if not re.fullmatch(r'%\d+', pane):+ raise ValueError('The Updates pane did not open.')+ hn('set-option', '-p', '-t', pane, OPTION, token, socket=socket)+ deadline = time.monotonic() + 5+ while time.monotonic() < deadline:+ if any(item[0] == pane and item[2] == token for item in updater_panes(socket)):+ return True+ time.sleep(.05)+ raise ValueError('The Updates screen did not start. Press Super+u to try again.')+++if __name__ == '__main__':+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument('--view', action='store_true', help='Inspect without requesting an update')+ args = parser.parse_args()+ if Path('/etc/harness-live').exists() or (args.view and os.geteuid() == 0):+ raise SystemExit(3 if args.view else 0)+ try:+ raise SystemExit(0 if open_updates(view=args.view) else 3)+ except (ValueError, OSError, subprocess.SubprocessError) as error:+ raise SystemExit('Harness updates: ' + str(error))diff --git a/os/tests/test_live_update.py b/os/tests/test_live_update.pyindex c1e6a0900..a356733b2 100644--- a/os/tests/test_live_update.py+++ b/os/tests/test_live_update.py@@ -4,6 +4,7 @@ import fcntlimport importlib.utilimport ioimport json+import osfrom pathlib import Pathimport structimport subprocess@@ -372,7 +373,7 @@ class FastUpdates(unittest.TestCase):update.prune()self.assertTrue(old_runtime.is_dir())- def show(self, keys, mouse=None, refresh=False):+ def show(self, keys, mouse=None, refresh=False, retry=False):class Window:def __init__(self): self.drawn, self.keys = [], iter(keys)def keypad(self, _): pass@@ -389,7 +390,7 @@ class FastUpdates(unittest.TestCase):with patch.object(update.curses, 'curs_set'), patch.object(update.curses, 'has_colors', return_value=False), \patch.object(update.curses, 'mousemask'), patch.object(update.curses, 'mouseinterval'), \patch.object(update.curses, 'getmouse', side_effect=event):- return update.screen(window, refresh=refresh)+ return update.screen(window, refresh=refresh, retry=retry)def test_update_button_click_and_keyboard_use_the_same_action_without_a_confirmation(self):with self.feed(): update.check()@@ -405,6 +406,111 @@ class FastUpdates(unittest.TestCase):self.assertEqual(self.show([]), 'update')self.assertFalse((self.state / 'request.json').exists())+ def test_targeted_request_is_inert_in_other_owned_or_direct_inspection(self):+ with self.feed(): update.check()+ request = dict(requested_at=1, target='a' * 32)+ update.write(self.state / 'request.json', request)+ for env in [{}, {'HARNESS_UPDATE_INSTANCE': 'b' * 32}]:+ with self.subTest(env=env), patch.dict(os.environ, env, clear=True):+ self.assertIsNone(self.show([27]))+ self.assertEqual(update.read(self.state / 'request.json'), request)+ with patch.dict(os.environ, {'HARNESS_UPDATE_INSTANCE': 'a' * 32}, clear=True):+ self.assertEqual(self.show([]), 'update')+ self.assertFalse((self.state / 'request.json').exists())++ def test_request_claim_holds_handoff_lock_through_match_and_unlink(self):+ from concurrent.futures import ThreadPoolExecutor+ import threading+ self.state.mkdir()+ first, second = dict(requested_at=1, target='a' * 32), dict(requested_at=2, target='b' * 32)+ update.write(self.state / 'request.json', first)+ matched, publishing, published = threading.Event(), threading.Event(), threading.Event()+ predicate = update.request_for_screen+ def match():+ result = predicate()+ matched.set()+ self.assertTrue(publishing.wait(timeout=2))+ self.assertFalse(published.is_set())+ return result+ def publish():+ self.assertTrue(matched.wait(timeout=2))+ with (self.state / 'open.lock').open('a') as lock:+ publishing.set()+ fcntl.flock(lock, fcntl.LOCK_EX)+ update.write(self.state / 'request.json', second)+ published.set()+ with (patch.dict(os.environ, {'HARNESS_UPDATE_INSTANCE': 'a' * 32}, clear=True),+ patch.object(update, 'request_for_screen', side_effect=match),+ ThreadPoolExecutor(max_workers=1) as pool):+ future = pool.submit(publish)+ self.assertTrue(update.consume_request())+ future.result(timeout=2)+ self.assertEqual(update.read(self.state / 'request.json'), second)++ def test_explicit_request_stays_compatible_and_private_target_is_validated(self):+ with patch.object(update.os, 'geteuid', return_value=1000), patch.dict(os.environ, {}, clear=True):+ update.main(['request'])+ self.assertEqual(set(update.read(self.state / 'request.json')), {'requested_at'})+ with patch.dict(os.environ, {'HARNESS_UPDATE_TARGET': 'c' * 32}):+ update.main(['request'])+ self.assertEqual(update.read(self.state / 'request.json')['target'], 'c' * 32)+ with patch.dict(os.environ, {'HARNESS_UPDATE_TARGET': 'invalid'}), self.assertRaisesRegex(ValueError, 'target'):+ update.main(['request'])+ self.assertEqual(update.read(self.state / 'request.json')['target'], 'c' * 32)++ def test_shortcut_after_last_poll_prevents_close_and_needs_no_second_key(self):+ with self.feed(): update.check()+ def keys():+ # The screen has polled request.json already. Super+u arrives just+ # before an older Escape is handled, while the process is alive.+ update.write(self.state / 'request.json', dict(requested_at=2, target='a' * 32))+ yield 27+ self.fail('The pending shortcut needed another key')+ with patch.dict(os.environ, {'HARNESS_UPDATE_INSTANCE': 'a' * 32}, clear=True):+ self.assertEqual(self.show(keys()), 'update')+ self.assertFalse((self.state / 'request.json').exists())++ def test_screen_registration_ends_before_close_returns_even_if_process_is_alive(self):+ proc = self.root / 'proc'+ pid = os.getpid()+ (proc / str(pid)).mkdir(parents=True)+ (proc / str(pid) / 'stat').write_text(f'{pid} (python) ' + ' '.join(['S'] + ['0'] * 18 + ['123']))+ with (patch.object(update, 'PROC', proc),+ patch.dict(os.environ, {'HARNESS_UPDATE_INSTANCE': 'a' * 32}, clear=True)):+ with update.screen_registration():+ record = update.read(self.state / 'screens' / str(pid))+ self.assertEqual(record, dict(pid=pid, start='123', token='a' * 32, boot_id='first-boot'))+ self.assertTrue(update.close_screen())+ self.assertFalse((self.state / 'screens' / str(pid)).exists())+ self.assertEqual(os.getpid(), pid) # Still before context/process cleanup.++ def test_unowned_terminal_screen_does_not_register_a_backend_pane_as_ui_identity(self):+ with patch.dict(os.environ, {'TMUX_PANE': '%7', 'HN_SOCKET': '/tmp/hn/default.sock'}, clear=True):+ with update.screen_registration():+ self.assertFalse((self.state / 'screens' / str(os.getpid())).exists())++ def test_close_waits_for_shortcut_handoff_then_preserves_its_pending_intent(self):+ from concurrent.futures import ThreadPoolExecutor+ import threading+ self.state.mkdir()+ marker = self.state / 'screens' / str(os.getpid())+ marker.parent.mkdir()+ marker.write_text('{}')+ entering = threading.Event()+ def close():+ entering.set()+ return update.close_screen()+ with (self.state / 'open.lock').open('a') as lock, ThreadPoolExecutor(max_workers=1) as pool:+ fcntl.flock(lock, fcntl.LOCK_EX)+ future = pool.submit(close)+ self.assertTrue(entering.wait(timeout=2))+ update.write(self.state / 'request.json', {'requested_at': 3})+ self.assertFalse(future.done())+ fcntl.flock(lock, fcntl.LOCK_UN)+ self.assertFalse(future.result(timeout=2))+ self.assertTrue(marker.exists())+ self.assertTrue((self.state / 'request.json').exists())+def test_restart_is_never_the_default_action_or_triggered_by_update_shortcut(self):self.state.mkdir()update.RESTART_REQUIRED.write_text('{"status":"ready"}')@@ -458,14 +564,18 @@ class FastUpdates(unittest.TestCase):self.assertIsNone(self.show([10], refresh=True))self.assertFalse((self.state / 'approved.json').exists())- def test_retry_keeps_the_request_so_recovered_downloads_apply_without_another_key(self):- with patch.object(update.os, 'geteuid', return_value=1000), \- patch.object(update.curses, 'wrapper', side_effect=['check', None]):+ def test_manual_retry_stays_local_and_applies_recovered_download_without_another_key(self):+ self.state.mkdir()+ other = dict(requested_at=1, target='b' * 32)+ update.write(self.state / 'request.json', other)+ with patch.dict(os.environ, {}, clear=True), patch.object(update.os, 'geteuid', return_value=1000), \+ patch.object(update.curses, 'wrapper', side_effect=['check', None]) as wrapper:update.main(['screen'])- self.assertTrue((self.state / 'request.json').exists())- with self.feed():- self.assertEqual(self.show([], refresh=True), 'update')- self.assertFalse((self.state / 'request.json').exists())+ self.assertTrue(wrapper.call_args_list[1].args[3])+ self.assertEqual(update.read(self.state / 'request.json'), other)+ with self.feed(), patch.dict(os.environ, {}, clear=True):+ self.assertEqual(self.show([], refresh=True, retry=True), 'update')+ self.assertEqual(update.read(self.state / 'request.json'), other)class RuntimeArchitecture(unittest.TestCase):diff --git a/os/tests/test_open_updates.py b/os/tests/test_open_updates.pynew file mode 100644index 000000000..e29eeef9b--- /dev/null+++ b/os/tests/test_open_updates.py@@ -0,0 +1,323 @@+import importlib.machinery+import importlib.util+import json+import os+from concurrent.futures import ThreadPoolExecutor+from pathlib import Path+import shutil+import subprocess+import tempfile+import threading+import unittest+from unittest.mock import patch++SOURCE = Path(__file__).resolve().parents[1] / 'root/usr/lib/harness-os/open-updates'+loader = importlib.machinery.SourceFileLoader('open_updates', str(SOURCE))+spec = importlib.util.spec_from_loader(loader.name, loader)+updates = importlib.util.module_from_spec(spec)+loader.exec_module(updates)+SOCKET = '/run/user/1000/hn/default.sock'+TOKEN, NEW_TOKEN = 'a' * 32, 'b' * 32+++class UpdatePaneOwnership(unittest.TestCase):+ def setUp(self):+ temporary = tempfile.TemporaryDirectory()+ self.addCleanup(temporary.cleanup)+ self.root = Path(temporary.name)+ self.proc = self.root / 'proc'+ self.rows, self.commands, self.targets = [], [], []+ self.attached = True+ self.boot_id = self.root / 'boot-id'+ self.boot_id.write_text('first-boot')+ for value in [patch.object(updates, 'PROC', self.proc),+ patch.object(updates, 'BOOT_ID', self.boot_id),+ patch.object(updates, 'STATE', self.root / 'state'),+ patch.object(updates, 'hn', side_effect=self.hn),+ patch.object(updates.secrets, 'token_hex', return_value=NEW_TOKEN),+ patch.dict(os.environ, {}, clear=True),+ patch.object(updates.subprocess, 'run')]:+ value.start()+ self.addCleanup(value.stop)+ self.request = updates.subprocess.run++ def process(self, pid, *, token=TOKEN, group=10, foreground=10,+ command=None, state='S', start=123, active=True):+ path = self.proc / str(pid)+ path.mkdir(parents=True, exist_ok=True)+ fields = [state, '1', str(group), '10', '34816', str(foreground)] + ['0'] * 13 + [str(start)]+ (path / 'stat').write_text(f'{pid} (a test (process)) ' + ' '.join(fields))+ argv = command if command is not None else ['/usr/bin/python3', updates.UPDATER, 'screen']+ (path / 'cmdline').write_bytes(b'\0'.join(word.encode() for word in argv) + b'\0')+ # Shipped daemon-backed panes have a backend TMUX_PANE and no HN_SOCKET.+ # Neither value may be used as the UI's pane/process mapping.+ (path / 'environ').write_bytes(('TMUX_PANE=%999\0HARNESS_UPDATE_INSTANCE=' + token + '\0').encode())+ screens = updates.STATE / 'screens'+ screens.mkdir(parents=True, exist_ok=True)+ if active:+ (screens / str(pid)).write_text(json.dumps(dict(+ pid=pid, start=str(start), token=token, boot_id='first-boot')))+ else:+ (screens / str(pid)).unlink(missing_ok=True)++ def pane(self, pane='%1', dead='0', window='@1', token=TOKEN):+ self.rows.append('\t'.join([pane, dead, window, token]))++ def hn(self, *args, socket=None):+ self.commands.append(args)+ self.targets.append((args, socket))+ if args == ('display-message', '-p', '#{socket_path}'):+ self.assertIsNone(socket)+ return SOCKET+ self.assertEqual(socket, SOCKET)+ if args[0] == 'hn-list-clients':+ self.assertEqual(args, ('hn-list-clients', '-F', '#{client_tty}'))+ return '/dev/pts/7' if self.attached else ''+ if args[0] == 'list-panes':+ self.assertEqual(args, ('list-panes', '-s', '-F', updates.FORMAT))+ return '\n'.join(self.rows)+ if args[0] == 'new-window':+ self.assertEqual(args, ('new-window', '-P', '-F', '#{pane_id}', '-n', 'Updates',+ 'exec env HARNESS_UPDATE_INSTANCE=' + NEW_TOKEN + ' /usr/bin/python3 ' + updates.UPDATER + ' screen'))+ self.pane('%9', window='@9', token='')+ self.process(900, token=NEW_TOKEN)+ return '%9'+ if args[0] == 'set-option':+ self.assertEqual(args, ('set-option', '-p', '-t', '%9', updates.OPTION, NEW_TOKEN))+ self.rows = [line.rsplit('\t', 1)[0] + '\t' + NEW_TOKEN if line.startswith('%9\t') else line for line in self.rows]+ return ''+ self.assertIn(args[0], ['select-window', 'select-pane'])+ return ''++ def assert_created_once(self):+ self.assertEqual(sum(item[0] == 'new-window' for item in self.commands), 1)+ self.assertNotIn(('select-window', '-t', 'Updates'), self.commands)++ def test_an_unrelated_named_shell_cannot_swallow_the_request(self):+ self.pane(token='')+ self.process(100, command=['/bin/bash'])+ updates.open_updates()+ self.assert_created_once()+ self.assertNotIn(('select-window', '-t', '@1'), self.commands)+ self.request.assert_called_once_with(['/usr/bin/harness', 'updates', 'request'],+ env={'HARNESS_UPDATE_TARGET': NEW_TOKEN}, check=True, timeout=5)++ def test_daemon_backed_owner_is_reused_without_backend_pid_or_socket_fields(self):+ self.pane()+ self.process(100)+ updates.open_updates()+ self.assertIn(('select-window', '-t', '@1'), self.commands)+ self.assertIn(('select-pane', '-t', '%1'), self.commands)+ self.assertFalse(any(item[0] == 'new-window' for item in self.commands))+ self.assertEqual(self.request.call_args.kwargs['env']['HARNESS_UPDATE_TARGET'], TOKEN)++ def test_manual_view_creates_no_request_and_next_shortcut_reuses_its_owner(self):+ self.assertTrue(updates.open_updates(view=True))+ self.request.assert_not_called()+ updates.open_updates()+ self.assert_created_once()+ self.request.assert_called_once()+ self.assertIn(('select-pane', '-t', '%9'), self.commands)++ def test_missing_dead_zombie_background_foreign_and_unregistered_are_not_reused(self):+ for case in ['missing', 'dead', 'zombie', 'background', 'token-mismatch', 'check', 'different-script', 'closed-screen']:+ with self.subTest(case=case):+ self.rows, self.commands = [], []+ shutil.rmtree(self.proc, ignore_errors=True)+ shutil.rmtree(updates.STATE, ignore_errors=True)+ self.pane(dead='1' if case == 'dead' else '0')+ if case != 'missing':+ self.process(100, state='Z' if case == 'zombie' else 'S',+ foreground=20 if case == 'background' else 10,+ token='c' * 32 if case == 'token-mismatch' else TOKEN,+ active=case != 'closed-screen',+ command=['/usr/bin/python3', updates.UPDATER, 'check'] if case == 'check' else+ ['/usr/bin/python3', '/tmp/live_update.py'] if case == 'different-script' else None)+ updates.open_updates()+ self.assert_created_once()+ self.assertNotIn(('select-window', '-t', '@1'), self.commands)++ def test_registration_must_match_process_environment_not_just_custom_option(self):+ self.pane()+ self.process(100)+ (self.proc / '100/environ').write_bytes(b'TMUX_PANE=%1\0')+ updates.open_updates()+ self.assert_created_once()++ def test_ambiguous_duplicate_process_token_is_not_reused(self):+ self.pane()+ self.process(100)+ self.process(101)+ updates.open_updates()+ self.assert_created_once()++ def test_exit_pid_reuse_pane_removal_or_marker_change_during_selection_creates_new_owner(self):+ for case in ['exit', 'pid-reuse', 'pane-removed', 'token-removed']:+ with self.subTest(case=case):+ self.rows, self.commands = [], []+ shutil.rmtree(self.proc, ignore_errors=True)+ shutil.rmtree(updates.STATE, ignore_errors=True)+ self.pane()+ self.process(100)+ def select(*args, **kwargs):+ result = self.hn(*args, **kwargs)+ if args[0] == 'select-pane':+ if case == 'pid-reuse':+ self.process(100, start=456)+ elif case == 'token-removed':+ self.rows = ['%1\t0\t@1\t']+ else:+ shutil.rmtree(self.proc / '100')+ if case == 'pane-removed':+ raise subprocess.CalledProcessError(1, 'hn')+ return result+ with patch.object(updates, 'hn', side_effect=select):+ updates.open_updates()+ self.assert_created_once()++ def test_rapid_shortcuts_wait_for_new_registration_and_reuse_one_pane(self):+ ready = threading.Barrier(2)+ queries = 0+ def delayed(*args, **kwargs):+ nonlocal queries+ result = self.hn(*args, **kwargs)+ if args[0] == 'list-panes':+ queries += 1+ if queries < 4:+ return ''+ return result+ def shortcut():+ ready.wait(timeout=2)+ updates.open_updates()+ with patch.object(updates, 'hn', side_effect=delayed), ThreadPoolExecutor(max_workers=2) as pool:+ futures = [pool.submit(shortcut) for _ in range(2)]+ for future in futures:+ future.result(timeout=3)+ self.assert_created_once()+ self.assertEqual(self.request.call_count, 2)+ self.assertIn(('select-pane', '-t', '%9'), self.commands)++ def test_failed_request_never_switches_or_creates_a_pane(self):+ self.request.side_effect = subprocess.CalledProcessError(1, 'harness')+ with self.assertRaises(subprocess.CalledProcessError):+ updates.open_updates()+ self.assertTrue(self.commands) # Discover an owner before targeting it.+ self.assertFalse(any(args[0] in ['select-window', 'select-pane', 'new-window'] for args in self.commands))++ def test_startup_failure_is_bounded_and_does_not_create_more_panes(self):+ def never_starts(*args, **kwargs):+ result = self.hn(*args, **kwargs)+ return '' if args[0] == 'list-panes' else result+ with (patch.object(updates, 'hn', side_effect=never_starts),+ patch.object(updates.time, 'monotonic', side_effect=[0, 6]),+ self.assertRaisesRegex(ValueError, 'did not start')):+ updates.open_updates()+ self.assert_created_once()++ def test_targeting_stays_pinned_if_default_client_changes_after_discovery(self):+ self.pane()+ self.process(100)+ updates.open_updates()+ self.assertEqual([args for args, socket in self.targets if socket is None],+ [('display-message', '-p', '#{socket_path}')])+ self.assertIn((('select-window', '-t', '@1'), SOCKET), self.targets)++ def test_registration_from_earlier_boot_or_reused_pid_is_not_an_owner(self):+ for key, value in [('boot_id', 'earlier-boot'), ('start', 'earlier-process')]:+ with self.subTest(key=key):+ self.rows, self.commands = [], []+ shutil.rmtree(self.proc, ignore_errors=True)+ shutil.rmtree(updates.STATE, ignore_errors=True)+ self.pane()+ self.process(100)+ path = updates.STATE / 'screens/100'+ record = json.loads(path.read_text())+ record[key] = value+ path.write_text(json.dumps(record))+ updates.open_updates()+ self.assert_created_once()++ def test_ssh_view_and_missing_client_fall_back_without_creating_request(self):+ with patch.dict(os.environ, {'SSH_CONNECTION': 'example'}):+ self.assertFalse(updates.open_updates(view=True))+ self.assertEqual(self.commands, [])+ with patch.object(updates, 'hn', side_effect=subprocess.CalledProcessError(1, 'hn')):+ self.assertFalse(updates.open_updates(view=True))+ self.request.assert_not_called()++ def test_valid_headless_socket_keeps_view_in_the_current_terminal(self):+ self.attached = False+ self.pane()+ self.process(100)+ self.assertFalse(updates.open_updates(view=True))+ self.request.assert_not_called()+ self.assertEqual(self.targets, [+ (('display-message', '-p', '#{socket_path}'), None),+ (('hn-list-clients', '-F', '#{client_tty}'), SOCKET)])+++class UpdateEntryPoints(unittest.TestCase):+ def setUp(self):+ temporary = tempfile.TemporaryDirectory()+ self.addCleanup(temporary.cleanup)+ self.root = Path(temporary.name)+ self.opener, self.python = self.root / 'opener', self.root / 'python'+ self.opener.write_text('#!/bin/sh\nprintf "%s\\n" "$@" > "$OPENER_LOG"\nexit "$OPENER_EXIT"\n')+ self.python.write_text('#!/bin/sh\nprintf "%s\\n" "$@" > "$PYTHON_LOG"\n')+ self.opener.chmod(0o755)+ self.python.chmod(0o755)+ self.wrapper = self.root / 'harness'+ source = SOURCE.parents[2] / 'bin/harness'+ self.wrapper.write_text(source.read_text().replace('/usr/lib/harness-os/open-updates', str(self.opener))+ .replace('/usr/bin/python3', str(self.python)))+ self.env = dict(os.environ, OPENER_LOG=str(self.root / 'opener.log'),+ PYTHON_LOG=str(self.root / 'python.log'), OPENER_EXIT='0')+ self.env.pop('SSH_CONNECTION', None)+ self.env.pop('SSH_TTY', None)++ def run_wrapper(self, *args, interactive=True):+ master, slave = os.openpty()+ try:+ result = subprocess.run(['/bin/sh', str(self.wrapper), 'updates', *args],+ stdin=slave if interactive else subprocess.DEVNULL,+ capture_output=True, env=self.env, timeout=5)+ finally:+ os.close(master)+ os.close(slave)+ return result++ def test_plain_and_screen_inspection_use_view_without_request(self):+ for args in [(), ('screen',)]:+ with self.subTest(args=args):+ self.assertEqual(self.run_wrapper(*args).returncode, 0)+ self.assertEqual((self.root / 'opener.log').read_text(), '--view\n')+ self.assertFalse((self.root / 'python.log').exists())++ def test_no_client_preserves_current_terminal_but_other_failure_does_not_duplicate_ui(self):+ self.env['OPENER_EXIT'] = '3'+ self.assertEqual(self.run_wrapper('screen').returncode, 0)+ self.assertEqual((self.root / 'python.log').read_text(), '/usr/lib/harness-os/live_update.py\nscreen\n')+ (self.root / 'python.log').unlink()+ self.env['OPENER_EXIT'] = '1'+ self.assertEqual(self.run_wrapper().returncode, 1)+ self.assertFalse((self.root / 'python.log').exists())++ def test_ssh_and_noninteractive_inspection_stays_in_current_terminal(self):+ for ssh in [False, True]:+ with self.subTest(ssh=ssh):+ if ssh:+ self.env['SSH_CONNECTION'] = 'client server'+ self.assertEqual(self.run_wrapper(interactive=ssh).returncode, 0)+ self.assertFalse((self.root / 'opener.log').exists())+ self.assertEqual((self.root / 'python.log').read_text(), '/usr/lib/harness-os/live_update.py\n')++ def test_other_actions_and_explicit_developer_arguments_are_forwarded_unchanged(self):+ for args in [('check',), ('request',), ('apply',), ('rollback',), ('status',), ('screen', '--feeds', '/tmp/developer.json')]:+ with self.subTest(args=args):+ self.assertEqual(self.run_wrapper(*args).returncode, 0)+ self.assertFalse((self.root / 'opener.log').exists())+ self.assertEqual((self.root / 'python.log').read_text(), '/usr/lib/harness-os/live_update.py\n' + '\n'.join(args) + '\n')+++if __name__ == '__main__':+ unittest.main()diff --git a/os/tests/update_context_vm.py b/os/tests/update_context_vm.pynew file mode 100644index 000000000..fdac05ea8--- /dev/null+++ b/os/tests/update_context_vm.py@@ -0,0 +1,194 @@+#!/usr/bin/env python3+"""Observe the shipped daemon-backed pane namespace in one private live VM."""+import argparse+import hashlib+import json+import os+from pathlib import Path+import shlex+import signal+import subprocess+import time+from unittest.mock import patch+from footprint_vm import copy_file+from hardware_install_vm import candidate_record, digest+from vm import VM++TOKEN = 'owned-context-observation'+FORMAT = '#{pane_id}\t#{pane_pid}\t#{pane_tty}\t#{pane_start_command}\t#{socket_path}\t#{@harness-update-context}'+FIELDS = ['pane', 'pid', 'tty', 'start_command', 'socket', 'custom_option']+IMAGE_SOURCE = 'b6cbaf3e3090f43106ad1ee47606349bd1a0ae89'+IMAGE_SHA256 = 'fa4f282644ac81e9e3b7de55276edd7dc08405e50875da544dc7f9fd6d50ba12'+IMAGE_BYTES = 2007023616+RUNTIME_SHA256 = {+ 'harness-tui': 'bd221059a24d7f7ca8ce69bb3b6d69c2fb66cb655aae6658627c278a548a8fa8',+ 'cli.mjs': '23b46a7c498fd1ef8ff5936aeb431f1de08b959b957141fa732d2cede870d147',+ 'notify.mjs': '5690159e964f9ce022bdb2a5e4bc9d853e595e822f254478df241e1386dde68e',+}+PROCESS = '''import json,os,sys,time+from pathlib import Path+def read_process(pid):+ root=Path('/proc')/str(pid)+ fields=(root/'stat').read_text().rsplit(')',1)[1].split()+ env=dict(item.split('=',1) for item in (root/'environ').read_bytes().decode().split('\\0') if '=' in item)+ return dict(pid=int(pid),start=fields[19],state=fields[0],group=fields[2],foreground=fields[5],+ stdin=str((root/'fd/0').readlink()),argv=(root/'cmdline').read_bytes().rstrip(b'\\0').decode().split('\\0'),+ env={k:env.get(k) for k in ['TMUX','TMUX_PANE','HN_SOCKET','HN_SOCKET_NAME','HARNESS_OS',+ 'HARNESS_TUI_BIN','MACHINE_ID','HARNESS_AGENT_ID','AGENT_ID','PORT','HARNESS_UPDATE_INSTANCE']})+if len(sys.argv)>1:+ records=[]+ for p in Path('/proc').iterdir():+ if not p.name.isdigit():continue+ try:+ if p.stat().st_uid!=os.getuid():continue+ argv=(p/'cmdline').read_bytes().rstrip(b'\\0').decode().split('\\0')+ if argv==['/usr/bin/python3','/usr/lib/harness-os/live_update.py'] or (+ argv==['python3','/tmp/update-context.py']):records.append(read_process(p.name))+ except (FileNotFoundError,ProcessLookupError):continue+ Path('/tmp/update-context-snapshot.json').write_text(json.dumps(records,indent=2)+'\\n')+else:+ Path('/tmp/update-context-owner.json').write_text(json.dumps(read_process(os.getpid()),indent=2)+'\\n')+ print('Harness updater context observation',flush=True)+ time.sleep(180)+'''+++def main():+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument('--iso', type=Path, required=True)+ parser.add_argument('--output', type=Path, default=Path('os/test-results/update-context'))+ args = parser.parse_args()+ assert os.access('/dev/kvm', os.R_OK | os.W_OK), 'Native x86 KVM is required'+ iso = args.iso.resolve()+ manifest = json.loads(iso.with_name('manifest.json').read_text())+ assert manifest['source_commit'] == manifest['harness_inputs']['source_commit'] == IMAGE_SOURCE+ assert manifest['iso']['sha256'] == digest(iso) == IMAGE_SHA256+ assert manifest['iso']['bytes'] == iso.stat().st_size == IMAGE_BYTES+ assert {name: info['sha256'] for name, info in manifest['harness_inputs']['files'].items()} == RUNTIME_SHA256+ folder = args.output.resolve()+ folder.mkdir(parents=True, exist_ok=False)+ receipt = dict(status='running', started_at=time.time(), budget_seconds=300,+ image_manifest=manifest, observer=candidate_record(Path(__file__)),+ helpers={name:candidate_record(Path(__file__).with_name(name)) for name in [+ 'vm.py', 'footprint_vm.py', 'hardware_install_vm.py']},+ process_observer_sha256=hashlib.sha256(PROCESS.encode()).hexdigest(),+ firmware='bios', cpu='Nehalem', memory_mib=2048, commands=[],+ scope='Live overlay only: stop installer, clear live marker and start packaged daemon/hn. No installation, candidate product overlay, update activation or runtime build.',+ limitations=['Runtime namespace observation, not ownership acceptance or physical hardware validation.'])+ vm = VM(folder, iso, 'bios', 2048, cpu='Nehalem')++ def save():+ (folder / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n')++ def user(command):+ # runuser retains the serial root shell's cwd; new panes need me's home.+ return 'runuser -u me -- env XDG_RUNTIME_DIR=/run/user/1000 DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/1000/bus sh -c ' + shlex.quote('cd /home/me && ' + command)++ def record(name, command, timeout=45, check=True):+ output, status = vm.command(command, timeout=timeout, check=False)+ (folder / (name + '.txt')).write_text(output)+ receipt['commands'].append(dict(name=name, command=command, status=status))+ save()+ assert not check or status == 0, (name, status, output[-2000:])+ return output++ def snapshot(name):+ record(name, user('python3 /tmp/update-context.py snapshot'))+ data = vm.read_file('/tmp/update-context-snapshot.json')+ (folder / (name + '.json')).write_bytes(data)+ return json.loads(data)++ def pane_format(name, pane):+ record(name, user('hn display-message -p -t ' + shlex.quote(pane) + ' ' ++ shlex.quote(FORMAT) + ' > /tmp/update-context-format'), check=False)+ data = vm.read_file('/tmp/update-context-format')+ (folder / (name + '.tsv')).write_bytes(data)+ values = data.decode().rstrip('\r\n').split('\t')+ result = dict(raw=data.decode(), fields=dict(zip(FIELDS, values)) if len(values) == len(FIELDS) else None)+ receipt[name] = result+ save()+ return result++ def deadline(*_):+ raise TimeoutError('300-second live context observation budget expired')++ real_popen = subprocess.Popen++ def restricted(command, *argv, **kwargs):+ if isinstance(command, list) and command[0] == 'qemu-system-x86_64':+ command = list(command)+ command[command.index('user,id=net')] = 'user,id=net,restrict=on'+ receipt['qemu_command'] = command+ return real_popen(command, *argv, **kwargs)++ try:+ signal.signal(signal.SIGALRM, deadline)+ signal.alarm(300)+ with patch('subprocess.Popen', restricted):+ vm.start(live=True)+ receipt['acceleration'] = vm.acceleration+ assert vm.acceleration == 'kvm'+ vm.wait(r'root@[^\r\n]*[#] ', timeout=110)+ vm.shell_ready = True+ vm.command('stty -echo')+ checksums = ''.join(info['sha256'] + ' /usr/lib/harness/' + name + '\n'+ for name, info in manifest['harness_inputs']['files'].items())+ record('01-frozen-runtime', 'printf %s ' + shlex.quote(checksums) + ' | sha256sum -c -')+ record('01-host-identity', 'uname -n > /tmp/context-hostname && uname -a > /tmp/context-kernel && ' ++ user('hn -V > /tmp/context-client-version'))+ receipt['guest'] = {key: vm.read_file('/tmp/context-' + key).decode().strip()+ for key in ['hostname', 'kernel', 'client-version']}+ paths = ['/usr/bin/harness', '/usr/lib/harness-os/live_update.py', '/usr/lib/harness-os/open-updates']+ receipt['packaged_files'] = {path:hashlib.sha256(vm.read_file(path)).hexdigest() for path in paths}+ record('02-live-session-ready', user('timeout 30 sh -c ' + shlex.quote(+ 'until systemctl --user is-active --quiet harness-install.service 2>/dev/null && '+ 'pgrep -u 1000 -x labwc >/dev/null; do sleep .2; done')), timeout=35)+ record('02-private-session', user('systemctl --user stop harness-install.service harness-update.timer harness-update.service') ++ ' && rm /etc/harness-live && ' + user('mkdir -p ~/.local/state/harness-os ~/projects; touch ~/.local/state/harness-os/onboarded; systemctl --user start harness-daemon.service hn-screen.service'), timeout=100)+ record('03-runtime-ready', user('/usr/lib/harness-os/wait-runtime && hn list-panes -s -F ' + shlex.quote(FORMAT)), timeout=45)+ copy_file(vm, PROCESS.encode(), '/tmp/update-context.py')+ record('04-create-pane', user("hn new-window -P -F '#{pane_id}' -n Observation " ++ shlex.quote('env HARNESS_UPDATE_INSTANCE=' + TOKEN + ' python3 /tmp/update-context.py') + ' > /tmp/update-context-pane'))+ record('05-await-process', "timeout 20 sh -c 'until test -s /tmp/update-context-owner.json; do sleep .1; done'", timeout=25)+ pane = vm.read_file('/tmp/update-context-pane').decode().strip()+ before = json.loads(vm.read_file('/tmp/update-context-owner.json'))+ receipt.update(pane=pane, original_process=before)+ assert pane.startswith('%') and pane[1:].isdigit(), pane+ assert before['env']['HARNESS_UPDATE_INSTANCE'] == TOKEN+ record('06-custom-option', user('hn set-option -p -t ' + shlex.quote(pane) + ' @harness-update-context ' + TOKEN), check=False)+ receipt['custom_option_status'] = receipt['commands'][-1]['status']+ pane_format('07-format-before', pane)+ record('08-manual-view', user("test ! -e ~/.local/state/harness-os/updates/request.json && hn new-window -n Manual '/usr/bin/harness updates'"))+ record('09-manual-started', 'timeout 15 sh -c ' + shlex.quote(+ "until pgrep -u 1000 -f '^/usr/bin/python3.*live_update.py' >/dev/null; do sleep .1; done"), timeout=20)+ snapshot('10-processes-before')+ record('11-no-apply-request', user('test ! -e ~/.local/state/harness-os/updates/request.json'))+ vm.screenshot('before-reconnect')+ record('12-renderer-reconnect', user('systemctl --user restart hn-screen.service && /usr/lib/harness-os/wait-runtime'), timeout=45)+ after = snapshot('13-processes-after')+ same = next(p for p in after if p['pid'] == before['pid'])+ assert all(same[key] == before[key] for key in ['pid', 'start', 'stdin', 'argv'])+ pane_format('14-format-after', pane)+ record('15-no-apply-request', user('test ! -e ~/.local/state/harness-os/updates/request.json'))+ record('16-frozen-runtime', 'printf %s ' + shlex.quote(checksums) + ' | sha256sum -c -')+ vm.screenshot('after-reconnect')+ receipt['status'] = 'passed'+ except BaseException as error:+ receipt.update(status='failed', error=repr(error))+ try:+ vm.screenshot('failure')+ except Exception as capture:+ receipt['capture_error'] = repr(capture)+ raise+ finally:+ signal.alarm(0)+ vm.stop()+ receipt['finished_at'] = time.time()+ save()+ vm.log.close()+ vm.stderr.close()+ vm.control.cleanup()+++if __name__ == '__main__':+ main()diff --git a/os/tests/update_pane_guest.py b/os/tests/update_pane_guest.pynew file mode 100644index 000000000..212fcfaff--- /dev/null+++ b/os/tests/update_pane_guest.py@@ -0,0 +1,78 @@+#!/usr/bin/env python3+"""Independent observation of updater processes and pane identity in a private VM."""+import argparse+import hashlib+import json+import os+from pathlib import Path+import subprocess++UPDATER = '/usr/lib/harness-os/live_update.py'+STATE = Path.home() / '.local/state/harness-os/updates'+++def process(pid):+ root = Path('/proc') / str(pid)+ fields = (root / 'stat').read_text().rsplit(')', 1)[1].split()+ return dict(pid=int(pid), start=fields[19], state=fields[0], group=fields[2],+ foreground=fields[5], argv=(root / 'cmdline').read_bytes().rstrip(b'\0').decode().split('\0'))+++def snapshot():+ template = '\t'.join('#{' + key + '}' for key in [+ 'pane_id', 'pane_pid', 'pane_dead', 'window_id', 'window_name',+ 'pane_active', 'window_active', 'socket_path', '@harness-update-instance'])+ output = subprocess.check_output(['hn', 'list-panes', '-s', '-F', template], text=True, timeout=5)+ panes = []+ for line in output.splitlines():+ values = line.split('\t')+ assert len(values) == 9, repr(line)+ panes.append(dict(zip(['pane', 'pid', 'dead', 'window', 'name', 'pane_active', 'window_active', 'socket', 'token'], values)))+ screens = []+ for path in Path('/proc').iterdir():+ if not path.name.isdigit():+ continue+ try:+ if path.stat().st_uid != os.getuid():+ continue+ record = process(path.name)+ if record['argv'] not in (['/usr/bin/python3', UPDATER], ['/usr/bin/python3', UPDATER, 'screen']):+ continue+ environment = dict(value.split('=', 1) for value in (path / 'environ').read_bytes().decode().split('\0') if '=' in value)+ record['backend_pane'] = environment.get('TMUX_PANE')+ record['primary_socket'] = environment.get('HN_SOCKET')+ record['token'] = environment.get('HARNESS_UPDATE_INSTANCE')+ matches = [p['pane'] for p in panes if record['token'] and p['token'] == record['token']]+ record['pane'] = matches[0] if len(matches) == 1 else None+ record['stdin'] = str((path / 'fd/0').readlink())+ registration = STATE / 'screens' / path.name+ record['registration'] = json.loads(registration.read_text()) if registration.exists() else None+ screens.append(record)+ except (FileNotFoundError, ProcessLookupError):+ continue+ return dict(panes=panes, screens=screens, request_pending=(STATE / 'request.json').exists(),+ boot_id=Path('/proc/sys/kernel/random/boot_id').read_text().strip())+++def work_identity():+ agent_ids = subprocess.check_output(['pgrep', '-u', str(os.getuid()), '-x', 'opencode'], text=True).split()+ daemon = subprocess.check_output(['systemctl', '--user', 'show', 'harness-daemon.service', '-p', 'MainPID', '--value'], text=True).strip()+ terminal = (Path.home() / 'projects/session-probe/pid').read_text().strip()+ return dict(agents=[process(pid) for pid in agent_ids], daemon=process(daemon), terminal=process(terminal),+ boot_id=Path('/proc/sys/kernel/random/boot_id').read_text().strip(),+ heartbeat=(Path.home() / 'projects/session-probe/heartbeat').stat().st_mtime_ns,+ runtime={str(path): hashlib.sha256(path.read_bytes()).hexdigest() for path in [+ Path('/usr/lib/harness/harness-tui'), Path('/usr/lib/harness/cli.mjs'), Path('/usr/lib/harness/notify.mjs')]})+++def main():+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument('action', choices=['snapshot', 'work'])+ parser.add_argument('output', type=Path)+ args = parser.parse_args()+ result = snapshot() if args.action == 'snapshot' else work_identity()+ args.output.write_text(json.dumps(result, indent=2) + '\n')+++if __name__ == '__main__':+ main()diff --git a/os/tests/update_pane_vm.py b/os/tests/update_pane_vm.pynew file mode 100644index 000000000..afe763904--- /dev/null+++ b/os/tests/update_pane_vm.py@@ -0,0 +1,373 @@+#!/usr/bin/env python3+"""Observe update shortcut ownership on a frozen, privately installed OS image."""+import argparse+import hashlib+import json+import os+from pathlib import Path+import shlex+import time+from footprint_vm import copy_file+from hardware_install_vm import candidate_record, digest+from session_vm import PROBE, screen_text+from vm import VM++UPDATER = '/usr/lib/harness-os/live_update.py'+OPENER = '/usr/lib/harness-os/open-updates'+WRAPPER = '/usr/bin/harness'+GUEST = '/home/me/update-pane-observer.py'+STATE = '/home/me/.local/state/harness-os/updates'+++def main():+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument('--iso', type=Path, required=True)+ parser.add_argument('--output', type=Path, default=Path('os/test-results/update-pane'))+ args = parser.parse_args()+ assert os.access('/dev/kvm', os.R_OK | os.W_OK), 'Native x86 KVM is required'+ iso = args.iso.resolve()+ manifest = json.loads(iso.with_name('manifest.json').read_text())+ assert digest(iso) == manifest['iso']['sha256'] and iso.stat().st_size == manifest['iso']['bytes']+ assert set(manifest['harness_inputs']['files']) == {'harness-tui', 'cli.mjs', 'notify.mjs'}+ folder = args.output.resolve()+ folder.mkdir(parents=True, exist_ok=False)+ (folder / 'image-manifest.json').write_text(json.dumps(manifest, indent=2) + '\n')+ root = Path(__file__).resolve().parents[1]+ candidates = {UPDATER: root / 'live_update.py', OPENER: root / 'root/usr/lib/harness-os/open-updates',+ WRAPPER: root / 'root/usr/bin/harness'}+ receipt = dict(status='running', started_at=time.time(), image_source=manifest['source_commit'],+ iso_sha256=manifest['iso']['sha256'], firmware='bios', memory_mib=2048, cpu='Nehalem',+ candidates={target: candidate_record(path) for target, path in candidates.items()},+ test_inputs={name: candidate_record(Path(__file__).with_name(name)) for name in [+ 'update_pane_vm.py', 'update_pane_guest.py', 'vm.py', 'session_vm.py',+ 'footprint_vm.py', 'hardware_install_vm.py']}, checks=[],+ limitations=['Updater-pane delivery and lifetime only; no new runtime or OS package activation.',+ 'Private loopback metadata offers no update; shared runtime bytes stay frozen.',+ 'No physical keyboard, Intel Mac, radio or GPU claim.'])+ vm = VM(folder, iso, 'bios', 2048, cpu='Nehalem')+ config = dict(disk='/dev/vda', expected_serial='HN_OS_TEST', confirm_erase='/dev/vda',+ username='me', hostname='harness', password='test-password-123', encrypt=False, serial_console=True)++ def observe(name, action='snapshot'):+ vm.command('python3 ' + GUEST + ' ' + action + ' /tmp/update-pane-observation.json')+ data = vm.read_file('/tmp/update-pane-observation.json')+ (folder / (name + '.json')).write_bytes(data)+ return json.loads(data)++ def active(snapshot):+ return [p for p in snapshot['screens'] if p['registration'] is not None+ and p['pane'] is not None and p['state'] not in ['Z', 'X']]++ def wait_active(name, expected=None):+ deadline = time.monotonic() + 15+ while time.monotonic() < deadline:+ record = observe(name)+ owners = active(record)+ if len(owners) == 1 and not record['request_pending']:+ owner = owners[0]+ pane = next(p for p in record['panes'] if p['pane'] == owner['pane'])+ if not (pane['dead'] == '0' and pane['pane_active'] == '1' and pane['window_active'] == '1'):+ time.sleep(.1)+ continue+ if expected:+ assert (owner['pid'], owner['start'], owner['pane']) == (expected['pid'], expected['start'], expected['pane']), record+ assert owner['stdin'].startswith('/dev/pts/') and owner['group'] == owner['foreground'], owner+ assert pane['token'] == owner['token']+ assert owner['registration'] == dict(pid=owner['pid'], start=owner['start'],+ token=owner['token'], boot_id=record['boot_id']), owner+ return record, owner+ time.sleep(.1)+ raise TimeoutError('One active updater did not consume the shortcut: ' + name)++ def wait_gone(previous):+ script = '''import time+from pathlib import Path+path=Path('/proc/%d/stat')+deadline=time.monotonic()+5+while time.monotonic()<deadline:+ try:+ start=path.read_text().rsplit(')',1)[1].split()[19]+ except FileNotFoundError:+ break+ if start != %r:+ break+ time.sleep(.05)+else: raise TimeoutError('Previous updater process did not exit')+''' % (previous['pid'], previous['start'])+ vm.command('python3 -c ' + shlex.quote(script), timeout=10)++ def wait_ui(name):+ deadline = time.monotonic() + 15+ while time.monotonic() < deadline:+ if 'up to date' in screen_text(vm, name):+ return+ time.sleep(.1)+ raise TimeoutError('Actual Updates screen did not render: ' + name)++ def work_survives(name, original):+ now = observe(name, 'work')+ for key in ['agents', 'daemon', 'terminal']:+ before = original[key] if key == 'agents' else [original[key]]+ after = now[key] if key == 'agents' else [now[key]]+ assert {(p['pid'], p['start']) for p in before} == {(p['pid'], p['start']) for p in after}, key+ assert all(p['state'] not in ['Z', 'X'] for p in after), key+ assert now['boot_id'] == original['boot_id'] and now['runtime'] == original['runtime']+ assert now['heartbeat'] > original['heartbeat']++ try:+ vm.start(live=True)+ receipt['acceleration'] = vm.acceleration+ vm.wait(r'root@[^\r\n]*[#] ')+ vm.shell_ready = True+ vm.command('stty -echo; nmcli networking off')+ copy_file(vm, json.dumps(config).encode(), '/tmp/install-config.json')+ output, _ = vm.command('harness install --config /tmp/install-config.json --yes-erase-disk', timeout=360)+ (folder / 'install.log').write_text(output)+ vm.command('sync')+ vm.stop()+ vm.start(live=False)+ vm.login_installed(config)+ vm.command('test "$HOME" = /home/me && test -d "$HOME/projects"')+ vm.command('printf %s ' + shlex.quote(config['password'] + '\n') + ' | sudo -S -v')+ vm.command('systemctl --user stop harness-update.timer harness-update.service')+ vm.command('test ! -e ' + STATE + '/ready.json && test ! -e ' + STATE + '/current && test ! -e ' + STATE + '/approved.json')+ vm.command('for n in $(seq 1 90); do pgrep -u 1000 -x opencode >/dev/null && exit 0; sleep .5; done; exit 1', timeout=50)+ copy_file(vm, Path(__file__).with_name('update_pane_guest.py').read_bytes(), GUEST)+ copy_file(vm, PROBE.encode(), '/home/me/update-pane-terminal.py')+ output, _ = vm.command("hn new-window -P -F '#{pane_id}' -n Updates 'python3 /home/me/update-pane-terminal.py' > /tmp/update-pane-terminal-id")+ vm.command('for n in $(seq 1 60); do test -s ~/projects/session-probe/pid && exit 0; sleep .1; done; exit 1')+ terminal = vm.read_file('/tmp/update-pane-terminal-id').decode().strip()+ before = observe('01-original-work', 'work')+ for path, expected in manifest['harness_inputs']['files'].items():+ assert before['runtime']['/usr/lib/harness/' + path] == expected['sha256']+ receipt['original_files'] = {path: hashlib.sha256(vm.read_file(path)).hexdigest() for path in candidates}+ original_opener = vm.read_file(OPENER)+ assert b'select-window -t Updates' in original_opener, 'This baseline fixture requires the legacy name-only adapter'+ (folder / 'original-open-updates').write_bytes(original_opener)+ vm.keys('meta_l', 'u')+ vm.command('timeout 5 sh -c \'until test -s ' + STATE + '/request.json; do sleep .05; done\'')+ baseline = observe('02-baseline-name-collision')+ assert not baseline['screens'] and baseline['request_pending'], baseline+ terminal_pane = next(p for p in baseline['panes'] if p['pane'] == terminal)+ assert terminal_pane['pane_active'] == '1' and terminal_pane['window_active'] == '1'++ def focus_terminal():+ vm.command('hn select-window -t ' + shlex.quote(terminal_pane['window']) ++ ' && hn select-pane -t ' + shlex.quote(terminal))++ vm.screenshot('02-baseline-name-collision')+ receipt['checks'].append('Original image adapter loses Super+u to the unrelated Updates terminal; no updater process exists and request remains pending.')++ # Real UI with deterministic, private release input: version 0.0.0+ # cannot activate anything. A missing OS channel is a normal 404.+ vm.command('mkdir -p /home/me/update-pane-feed')+ ref = dict(url='http://127.0.0.1:19447/unused', sha256='0' * 64, size=1)+ feeds = {'hn': {'version': '0.0.0', 'builds': {'linux-x64': ref}},+ 'cli': {'cli': {'version': '0.0.0', 'cli': ref, 'notify': ref}}}+ for name, value in feeds.items():+ copy_file(vm, json.dumps(value).encode(), '/home/me/update-pane-feed/' + name + '.json')+ vm.command('systemd-run --user --collect --unit=harness-test-feed python3 -m http.server 19447 --bind 127.0.0.1 --directory /home/me/update-pane-feed')+ vm.command('for n in $(seq 1 30); do curl -fsS http://127.0.0.1:19447/hn.json && exit 0; sleep .1; done; exit 1')+ candidate = candidates[UPDATER].read_text()+ fixture = candidate+ for component, filename in [('tui', 'hn'), ('cli', 'cli')]:+ address = "'https://storage.googleapis.com/s3-autonomous-upgrade-3/harness/" + component + "/metadata.json'"+ assert fixture.count(address) == 1+ fixture = fixture.replace(address, "'http://127.0.0.1:19447/" + filename + ".json'")+ marker = 'release = module.discover()'+ assert fixture.count(marker) == 1+ fixture = fixture.replace(marker, "release = module.discover('http://127.0.0.1:19447/no-os-channel.json')")+ # Hold the *same* process alive after the real close decision released+ # open.lock and removed its registration. No close result is forged.+ trace = '''+_observed_consume_request = consume_request+def consume_request():+ gate = Path('/tmp/update-pane-route-gate')+ request = read(STATE / 'request.json', {})+ target = gate.read_text().strip() if gate.exists() else None+ if target and request.get('target') == target:+ token = os.environ.get('HARNESS_UPDATE_INSTANCE')+ if token == target:+ deadline = time.monotonic() + 10+ while not Path('/tmp/update-pane-route-rejected.json').exists():+ if time.monotonic() >= deadline:+ raise TimeoutError('Direct inspection did not reject targeted request')+ time.sleep(.05)+ claimed = _observed_consume_request()+ kind = 'claimed' if token == target else 'rejected'+ write(Path('/tmp/update-pane-route-' + kind + '.json'), dict(+ pid=os.getpid(), token=token, request=request, claimed=claimed))+ return claimed+ return _observed_consume_request()++_observed_close_screen = close_screen+def close_screen():+ closed = _observed_close_screen()+ hold = Path('/tmp/update-pane-hold-close')+ if closed and hold.exists() and hold.read_text().strip() == str(os.getpid()):+ Path('/tmp/update-pane-close-committed').write_text(str(os.getpid()))+ deadline = time.monotonic() + 30+ while not Path('/tmp/update-pane-release-close').exists() and time.monotonic() < deadline:+ time.sleep(.05)+ return closed++'''+ assert fixture.count("if __name__ == '__main__':") == 1+ fixture = fixture.replace("if __name__ == '__main__':", trace + "if __name__ == '__main__':")+ compile(fixture, 'observed-live-update.py', 'exec')+ (folder / 'observed-live-update.py').write_text(fixture)+ receipt['private_observer'] = dict(sha256=hashlib.sha256(fixture.encode()).hexdigest(),+ differences=['hn and CLI feed URLs use loopback version 0.0.0 metadata.',+ 'OS discovery receives its supported explicit loopback feed argument; endpoint returns 404.',+ 'For one targeted handoff, owned consume waits up to 10 seconds for a direct inspection to execute the real consume and reject that target; both actual outcomes are retained.',+ 'After real close_screen returns True, one selected test process waits for release, at most 30 seconds.'])+ copy_file(vm, fixture.encode(), '/tmp/update-pane-ui.py')+ copy_file(vm, candidates[OPENER].read_bytes(), '/tmp/update-pane-opener')+ copy_file(vm, candidates[WRAPPER].read_bytes(), '/tmp/update-pane-wrapper')+ vm.command('sudo install -m 644 /tmp/update-pane-ui.py ' + UPDATER ++ ' && sudo install -m 755 /tmp/update-pane-opener ' + OPENER ++ ' && sudo install -m 755 /tmp/update-pane-wrapper ' + WRAPPER + ' && sudo nmcli networking off')+ assert hashlib.sha256(vm.read_file(OPENER)).hexdigest() == receipt['candidates'][OPENER]['sha256']+ assert hashlib.sha256(vm.read_file(WRAPPER)).hexdigest() == receipt['candidates'][WRAPPER]['sha256']+ assert hashlib.sha256(vm.read_file(UPDATER)).hexdigest() == receipt['private_observer']['sha256']+ vm.keys('meta_l', 'u')+ first, owner = wait_active('03-owned-updater')+ wait_ui('03-owned-updater')+ assert owner['pane'] != terminal+ receipt['checks'].append('Super+u opens a real registered Updates UI beside the unrelated named terminal, and it consumes the request.')+ for index in range(3):+ focus_terminal()+ vm.keys('meta_l', 'u')+ wait_active('04-repeated-shortcut-' + str(index), owner)+ pane = next(p for p in first['panes'] if p['pane'] == owner['pane'])+ vm.command('hn rename-window -t ' + shlex.quote(pane['window']) + ' Versions')+ focus_terminal()+ vm.keys('meta_l', 'u')+ wait_active('05-renamed-updater', owner)+ receipt['checks'].append('Repeated Super+u and a renamed updater reuse its same PID/start time and pane rather than creating duplicate tabs.')++ vm.command('systemctl --user restart hn-screen.service; /usr/lib/harness-os/wait-runtime', timeout=90)+ focus_terminal()+ vm.keys('meta_l', 'u')+ resumed, _ = wait_active('06-renderer-reconnected', owner)+ resumed_pane = next(p for p in resumed['panes'] if p['pane'] == owner['pane'])+ receipt['socket_handover'] = dict(process_environment=owner['primary_socket'],+ before=pane['socket'], after=resumed_pane['socket'])+ wait_ui('06-renderer-reconnected')+ work_survives('06-work-preserved', before)+ receipt['checks'].append('After actual renderer restart, the same token-bound updater and work processes survive without requiring HN_SOCKET or a particular socket alias name.')++ vm.command('kill -TERM ' + str(owner['pid']))+ wait_gone(owner)+ vm.command('test ! -e ' + STATE + '/request.json')+ vm.command("hn new-window -P -F '#{pane_id}' -n Manual '/usr/bin/harness updates; sleep 120' > /tmp/update-pane-manual-caller")+ manual, owner = wait_active('07-manual-view')+ caller = vm.read_file('/tmp/update-pane-manual-caller').decode().strip()+ assert owner['pane'] != caller and any(p['pane'] == caller for p in manual['panes']), manual+ vm.command('test ! -e ' + STATE + '/request.json')+ focus_terminal()+ vm.keys('meta_l', 'u')+ wait_active('07-manual-view-reused', owner)+ wait_ui('07-manual-view-reused')+ receipt['checks'].append('Manual harness updates opens an owned inspection pane without an apply request, preserves its caller terminal, and the next Super+u reuses that same actual UI process.')++ # A valid headless endpoint is not a visible client. Manual inspection+ # must remain on its caller's real terminal and never consume another+ # screen's targeted shortcut. Use a separate private hn namespace.+ vm.command("hn -L update-pane-headless new-session -d -s inspection 'sleep 120' && "+ "hn -L update-pane-headless display-message -p '#{socket_path}' > /tmp/update-pane-headless-socket")+ headless = vm.read_file('/tmp/update-pane-headless-socket').decode().strip()+ assert headless.startswith('/') and '\n' not in headless, headless+ headless_command = 'hn -S ' + shlex.quote(headless)+ vm.command(headless_command + " hn-list-clients -F '#{client_tty}' > /tmp/update-pane-headless-clients && " ++ headless_command + " list-panes -s -F '#{pane_id}' > /tmp/update-pane-headless-before")+ assert not vm.read_file('/tmp/update-pane-headless-clients').strip()+ default_socket = next(p for p in manual['panes'] if p['pane'] == owner['pane'])['socket']+ vm.command('hn -S ' + shlex.quote(default_socket) + " new-window -P -F '#{pane_id}' -n Inspection " ++ shlex.quote('env HN_SOCKET=' + headless + ' /usr/bin/harness updates; sleep 120') ++ ' > /tmp/update-pane-inspection-caller')+ inspection_pane = vm.read_file('/tmp/update-pane-inspection-caller').decode().strip()+ deadline = time.monotonic() + 15+ while time.monotonic() < deadline:+ inspected = observe('07-direct-inspection')+ direct = [p for p in inspected['screens'] if p['registration'] is None and p['token'] is None]+ if len(direct) == 1:+ inspection = direct[0]+ assert inspection['primary_socket'] == headless+ assert inspection['group'] == inspection['foreground'] and inspection['stdin'].startswith('/dev/pts/')+ visible = next(p for p in inspected['panes'] if p['pane'] == inspection_pane)+ assert visible['pane_active'] == '1' and visible['window_active'] == '1'+ break+ time.sleep(.1)+ else:+ raise TimeoutError('Manual inspection did not stay in its caller terminal')+ wait_ui('07-direct-inspection')+ vm.command(headless_command + " list-panes -s -F '#{pane_id}' > /tmp/update-pane-headless-after")+ assert vm.read_file('/tmp/update-pane-headless-before') == vm.read_file('/tmp/update-pane-headless-after')+ assert not inspected['request_pending']+ vm.command('printf %s ' + owner['token'] + ' > /tmp/update-pane-route-gate')+ focus_terminal()+ vm.keys('meta_l', 'u')+ delivered, _ = wait_active('07-targeted-delivery', owner)+ vm.command("timeout 5 sh -c 'until test -s /tmp/update-pane-route-rejected.json && "+ "test -s /tmp/update-pane-route-claimed.json; do sleep .05; done'")+ evidence = {kind: json.loads(vm.read_file('/tmp/update-pane-route-' + kind + '.json'))+ for kind in ['rejected', 'claimed']}+ rejected, claimed = evidence['rejected'], evidence['claimed']+ assert rejected['pid'] == inspection['pid'] and rejected['token'] is None and rejected['claimed'] is False+ assert claimed['pid'] == owner['pid'] and claimed['token'] == owner['token'] and claimed['claimed'] is True+ assert rejected['request'] == claimed['request'] and claimed['request']['target'] == owner['token']+ assert any(p['pid'] == inspection['pid'] and p['start'] == inspection['start'] and p['registration'] is None+ for p in delivered['screens'])+ (folder / '07-targeted-delivery-outcomes.json').write_text(json.dumps(evidence, indent=2) + '\n')+ receipt['headless_inspection'] = dict(socket=headless, caller_pane=inspection_pane, process=inspection,+ pane_ids=vm.read_file('/tmp/update-pane-headless-after').decode())+ vm.command('rm /tmp/update-pane-route-gate')+ vm.command('kill -TERM ' + str(inspection['pid']))+ wait_gone(inspection)+ receipt['checks'].append('A manual view with a valid headless socket stays in its current PTY without creating a hidden pane or an apply request. While it remains alive, its real consume rejects the targeted shortcut before the selected owner claims that exact request.')++ vm.command('printf %s ' + str(owner['pid']) + ' > /tmp/update-pane-hold-close')+ vm.keys('esc')+ vm.command('timeout 5 sh -c \'until test -s /tmp/update-pane-close-committed; do sleep .05; done\'')+ closing = observe('08-close-committed-process-alive')+ old = next(p for p in closing['screens'] if p['pid'] == owner['pid'])+ assert old['registration'] is None and old['start'] == owner['start'] and old['state'] not in ['Z', 'X'], closing+ vm.keys('meta_l', 'u')+ replacement, replacement_owner = wait_active('09-closing-screen-replaced')+ old = next(p for p in replacement['screens'] if p['pid'] == owner['pid'])+ assert old['registration'] is None and old['start'] == owner['start'] and old['state'] not in ['Z', 'X'], replacement+ assert replacement_owner['pid'] != owner['pid'] and replacement_owner['pane'] != owner['pane']+ vm.screenshot('09-closing-screen-replaced')+ vm.command('touch /tmp/update-pane-release-close')+ receipt['checks'].append('A real Escape commits closing and unregisters; while the same Python PID remains alive, Super+u opens one replacement that consumes its request.')++ focus_terminal()+ vm.type_probe('ownership-input-survives')+ vm.keys('ret')+ vm.command("timeout 5 sh -c 'until grep -Fx ownership-input-survives ~/projects/session-probe/input; do sleep .1; done'")+ vm.screenshot('10-original-terminal-input')+ work_survives('10-final-work-preserved', before)+ receipt['checks'].append('Original named terminal accepts actual QMP keyboard input; its heartbeat, OpenCode, daemon and boot identities survive, and frozen runtime hashes are unchanged.')+ receipt['status'] = 'passed'+ except BaseException as error:+ receipt.update(status='failed', error=repr(error))+ if vm.process and vm.process.poll() is None:+ try:+ vm.screenshot('failure')+ output, _ = vm.command('journalctl --user -n 150 --no-pager; hn list-panes -a -F "#{pane_id} #{pane_pid} #{pane_dead} #{window_name} #{socket_path}"', timeout=15, check=False)+ (folder / 'failure.log').write_text(output)+ except Exception:+ pass+ raise+ finally:+ receipt['finished_at'] = time.time()+ (folder / 'receipt.json').write_text(json.dumps(receipt, indent=2) + '\n')+ vm.stop()+ vm.log.close()+ vm.stderr.close()+ vm.control.cleanup()+++if __name__ == '__main__':+ main()