A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
compare prerelease versions correctly in reconnect advice (#3566)
Sebastian Müller18c5519dc20c
diff --git a/crates/pa-tui/src/daemon_reconnect.rs b/crates/pa-tui/src/daemon_reconnect.rsindex 83ae5d2257..6015aeb56f 100644--- a/crates/pa-tui/src/daemon_reconnect.rs+++ b/crates/pa-tui/src/daemon_reconnect.rs@@ -3,6 +3,7 @@//! is NEWER than this window's binary, the recovered row says so.use crate::chat::StatusKind;+use std::cmp::Ordering;/// The reconnect driver that owns the run: which daemon closing armed it/// decides the reattach banner and the expiry row.@@ -55,44 +56,95 @@ pub(crate) fn reconnect_banner(/// The numeric version prefixes order segment by segment; a numeric-equal/// release outranks the client's own prerelease (semver: "1.2.3" >/// "1.2.3-beta.1"), so a prerelease window still gets the restart advice.+/// Two prereleases of the same prefix order by `compare_prerelease_identifiers`.fn is_daemon_version_newer(daemon_version: &str, client_version: &str) -> bool {let daemon = parse_numeric_version_prefix(daemon_version);let client = parse_numeric_version_prefix(client_version);for index in 0..daemon.len().max(client.len()) {- let daemon_segment = daemon.get(index).copied().unwrap_or(0);- let client_segment = client.get(index).copied().unwrap_or(0);- if daemon_segment != client_segment {- return daemon_segment > client_segment;+ let daemon_segment = daemon.get(index).copied().unwrap_or("0");+ let client_segment = client.get(index).copied().unwrap_or("0");+ let ordering = compare_numeric_identifiers(daemon_segment, client_segment);+ if ordering != Ordering::Equal {+ return ordering == Ordering::Greater;+ }+ }+ let daemon_ids = prerelease_identifiers(daemon_version);+ let client_ids = prerelease_identifiers(client_version);+ match (daemon_ids.is_empty(), client_ids.is_empty()) {+ (_, true) => false,+ (true, false) => true,+ (false, false) => {+ compare_prerelease_identifiers(&daemon_ids, &client_ids) == Ordering::Greater}}- !has_prerelease_suffix(daemon_version) && has_prerelease_suffix(client_version)}-/// The dot- and dash-separated segments of a version ("1.2.3-beta.1" ->-/// `["1", "2", "3", "beta", "1"]`).-fn split_version_segments(value: &str) -> Vec<&str> {- value.split(['.', '-']).collect()+/// Build metadata never contributes to Semver precedence.+fn version_without_build(value: &str) -> &str {+ value.split('+').next().unwrap_or(value)}-/// The leading numeric segments; the first unparseable segment ends the-/// prefix.-fn parse_numeric_version_prefix(value: &str) -> Vec<u64> {+/// The leading numeric segments of the release prefix; the first+/// unparseable segment ends the prefix for nonstandard development versions.+fn parse_numeric_version_prefix(value: &str) -> Vec<&str> {+ let release = version_without_build(value)+ .split('-')+ .next()+ .unwrap_or(value);let mut segments = Vec::new();- for segment in split_version_segments(value) {- let Ok(parsed) = segment.parse::<u64>() else {+ for segment in release.split('.') {+ if segment.is_empty() || !segment.bytes().all(|byte| byte.is_ascii_digit()) {break;- };- segments.push(parsed);+ }+ segments.push(segment);}segments}-/// Whether the version continues past its numeric prefix with a-/// prerelease suffix.-fn has_prerelease_suffix(value: &str) -> bool {- let segments = split_version_segments(value);- let prefix_len = parse_numeric_version_prefix(value).len();- prefix_len > 0 && prefix_len < segments.len()+/// Prerelease identifiers split on dots only: hyphens belong to an+/// identifier, and even an entirely numeric prerelease remains a prerelease.+fn prerelease_identifiers(value: &str) -> Vec<&str> {+ let value = version_without_build(value);+ if let Some((_, prerelease)) = value.split_once('-') {+ return prerelease.split('.').collect();+ }+ // Preserve the existing treatment of nonstandard development strings.+ value+ .split('.')+ .skip(parse_numeric_version_prefix(value).len())+ .collect()+}++/// Decimal length then lexical order compares arbitrarily large numeric+/// identifiers, retaining the accepted leading-zero behavior of core versions.+fn compare_numeric_identifiers(daemon: &str, client: &str) -> Ordering {+ let daemon_number = daemon.trim_start_matches('0');+ let client_number = client.trim_start_matches('0');+ daemon_number+ .len()+ .cmp(&client_number.len())+ .then_with(|| daemon_number.cmp(client_number))+}++/// Semver §11 ordering of two prerelease identifier lists: identifiers+/// compare left to right — numeric ones numerically, alphanumeric ones+/// lexically, numeric below alphanumeric — and the list with more+/// identifiers wins when the shared ones are equal.+fn compare_prerelease_identifiers(daemon: &[&str], client: &[&str]) -> Ordering {+ for (daemon_id, client_id) in daemon.iter().zip(client) {+ let daemon_numeric = daemon_id.bytes().all(|byte| byte.is_ascii_digit());+ let client_numeric = client_id.bytes().all(|byte| byte.is_ascii_digit());+ let ordering = match (daemon_numeric, client_numeric) {+ (true, true) => compare_numeric_identifiers(daemon_id, client_id),+ (true, false) => Ordering::Less,+ (false, true) => Ordering::Greater,+ (false, false) => daemon_id.cmp(client_id),+ };+ if ordering != Ordering::Equal {+ return ordering;+ }+ }+ daemon.len().cmp(&client.len())}#[cfg(test)]@@ -131,6 +183,59 @@ mod tests {);}+ #[test]+ fn build_metadata_does_not_change_precedence() {+ assert!(!is_daemon_version_newer("1.2.3+daemon", "1.2.3+client"));+ assert!(!is_daemon_version_newer(+ "1.2.3-beta.1+daemon",+ "1.2.3-beta.1"+ ));+ assert!(is_daemon_version_newer(+ "1.2.3+daemon",+ "1.2.3-beta.1+client"+ ));+ assert!(is_daemon_version_newer("1.2.4+daemon", "1.2.3+client"));+ }++ #[test]+ fn hyphens_belong_to_the_prerelease_identifier() {+ assert!(is_daemon_version_newer("1.2.3-alpha-2", "1.2.3-alpha-10"));+ assert!(is_daemon_version_newer("1.2.3-alpha-10", "1.2.3-alpha.10"));+ assert!(!is_daemon_version_newer("1.2.3-20", "1.2.3"));+ assert!(!is_daemon_version_newer("1.2.3-20", "1.2.3-alpha"));+ }++ #[test]+ fn numeric_prerelease_identifiers_have_no_integer_size_limit() {+ assert!(is_daemon_version_newer(+ "1.2.3-beta.100000000000000000000",+ "1.2.3-beta.99999999999999999999"+ ));+ assert!(!is_daemon_version_newer(+ "1.2.3-beta.100000000000000000000",+ "1.2.3-beta.alpha"+ ));+ }++ #[test]+ fn numeric_core_segments_have_no_integer_size_limit() {+ for (newer, older) in [+ ("100000000000000000000.0.0", "2.0.0"),+ ("1.100000000000000000000.0", "1.99999999999999999999.0"),+ ("1.2.100000000000000000000", "1.2.99999999999999999999"),+ ] {+ assert!(is_daemon_version_newer(newer, older), "{newer} > {older}");+ assert!(!is_daemon_version_newer(older, newer), "{older} < {newer}");+ }+ assert!(is_daemon_version_newer(+ "100000000000000000000.0.0",+ "100000000000000000000.0.0-beta.1"+ ));+ assert!(!is_daemon_version_newer("01.002.0003", "1.2.3"));+ assert!(!is_daemon_version_newer("1.2.0", "1.2"));+ assert!(!is_daemon_version_newer("1..9", "1.2.0"));+ }+/// TS `isDaemonVersionNewer`: numeric-prefix ordering with the semver prerelease rule.#[test]fn the_version_order_follows_the_ts_rules() {@@ -141,6 +246,7 @@ mod tests {assert!(!is_daemon_version_newer("1.2.3-beta.1", "1.2.3"));assert!(!is_daemon_version_newer("1.2.3-beta.2", "1.2.3-beta.10"));assert!(!is_daemon_version_newer("1.2.3-beta.1", "1.2.3-beta.2"));+ assert!(is_daemon_version_newer("0.10.1-beta.20", "0.10.1-beta.8"));// An unparseable version has an empty prefix: it reads as all zeros, so a real release// orders above it but never below.assert!(!is_daemon_version_newer("dev", "0.1.0"));diff --git a/scripts/review_draft_disconnect_parity.py b/scripts/review_draft_disconnect_parity.pyindex f40ab2e445..ca0bf43928 100644--- a/scripts/review_draft_disconnect_parity.py+++ b/scripts/review_draft_disconnect_parity.py@@ -387,6 +387,21 @@ class Supervisor:response["data"] = fixture_state(self.root, active)with self.lock:response["data"]["messageCount"] = len(self.messages)+ elif name == "get_messages":+ # pa-daemon worker::commands::handle_get_messages and TS+ # daemon-mode get_messages return the actual transcript.+ # Fixture turns only append; no branches/pagination are used.+ with self.lock:+ response["data"] = {"messages": list(self.messages)}+ elif name == "get_session_context":+ # pa-daemon state_getters::handle_get_session_context's+ # context envelope. This fixture has no compaction or+ # model/thinking/tier change rows: build_session_context+ # preserves its turns and uses off/None/None defaults.+ with self.lock:+ response["data"] = {"context": {+ "messages": list(self.messages), "thinkingLevel": "off",+ "serviceTier": None, "model": None}}elif name == "get_mcp_connections": response["data"] = {"connections": []}elif name == "detach": response["data"] = {}elif name == "set_auto_compaction":diff --git a/scripts/review_reconnect_version_parity.py b/scripts/review_reconnect_version_parity.pynew file mode 100644index 0000000000..81efd2b0d1--- /dev/null+++ b/scripts/review_reconnect_version_parity.py@@ -0,0 +1,195 @@+#!/usr/bin/env python3+"""Compare actual TS/Rust reconnect banners, recording the SemVer correction.++The pinned TS runtime treats an all-numeric suffix as another release segment;+Rust deliberately corrects that invalid precedence. Raw screens and both actual+versions are retained. The ordinary post-reconnect command catalog response is+held until capture because TS resync can erase the transient status before paint.+This checks version advice, not restart durability. No fake renderer or extracted+comparator executes here.+"""+import argparse+import errno+import json+import os+from pathlib import Path+import re+import socket+import tempfile+import threading+import uuid++from review_draft_disconnect_parity import (Supervisor, Terminal, actual_hello,+ digest, env_for, fixture_state, TS_ARCHIVE_SHA256)+++def runtime_version(binary, root, env):+ import subprocess+ probe = subprocess.run([str(binary), '--version'], cwd=root, env=env,+ text=True, capture_output=True, timeout=10, check=True)+ matches = re.findall(r'\d+\.\d+\.\d+(?:[-+][\w.+-]+)?', probe.stdout)+ if len(matches) != 1:+ raise RuntimeError('cannot identify actual runtime version: ' + probe.stdout)+ return matches[0]+++class RestartSupervisor(Supervisor):+ def __init__(self, *args):+ self.release_catalog = threading.Event()+ self.catalog_held = threading.Event()+ super().__init__(*args)++ def send(self, sock, data):+ if self.closed and data.get('type') == 'response' and data.get('command') == 'get_commands':+ # TS shows the status before its asynchronous resync rebuild clears+ # the transcript. Hold that rebuild at its ordinary catalog request+ # so a real terminal frame can expose the comparator's banner.+ self.catalog_held.set()+ if not self.release_catalog.wait(35):+ raise TimeoutError('restart catalog gate was not released')+ if data.get('type') == 'response' and data.get('command') in ('attach', 'list'):+ # Announced restart recovery locates its durable session in list+ # before attaching it, unlike the ordinary transport EOF path.+ summary = fixture_state(self.root, 's1')+ summary.update(id='s1', sessionFile=str(self.root / 'agent/sessions/fixture.jsonl'))+ if data['command'] == 'attach':+ payload = dict(data['data'])+ payload['snapshot'] = dict(payload['snapshot'], summary=summary)+ data = dict(data, data=payload)+ else:+ data = dict(data, data={'sessions': [summary]})+ super().send(sock, data)++ def restart(self, version):+ # Both clients reserve the versioned restart banner for an announced+ # daemon shutdown/update. A bare EOF exercises transport recovery and+ # emits a different generic reconnect status.+ with self.lock:+ connections = [connection for connection in self.sockets if connection.fileno() >= 0]+ self.hello = dict(self.hello, appVersion=version,+ supervisorGeneration=str(uuid.uuid4()))+ self.closed = True+ for connection in connections:+ try:+ self.send(connection, {'type': 'daemon_closing', 'reason': 'shutdown'})+ self.send(connection, {'type': 'session_closed', 'activeSessionId': 's1',+ 'reason': 'shutdown'})+ connection.shutdown(socket.SHUT_RDWR)+ except OSError as error:+ if error.errno not in (errno.EBADF, errno.EPIPE, errno.ECONNRESET, errno.ENOTCONN):+ raise+++def run_case(kind, binary, root, hello, client, name, observed=None):+ root.mkdir()+ env = env_for(root, kind)+ base = client.split('+')[0].split('-')[0]+ parts = [int(x) for x in base.split('.')]+ newer = f'{parts[0] + 1}.0.0'+ versions = {'same': client, 'newer': newer, 'older': '0.0.0',+ 'metadata': base + '+fixture', 'numeric_prerelease': base + '-20'}+ daemon = versions[name]+ observed = observed if observed is not None else {}+ observed.update(daemon_version=daemon, client_version=client, executed=False)+ path = root / 'fixture.sock'+ fixture_hello = dict(hello, socketPath=str(path), supervisorSocketPath=str(path))+ server = RestartSupervisor(path, fixture_hello, 'restart', root)+ terminal = None+ try:+ terminal = Terminal([str(binary), '--daemon-socket', str(server.path)], root, env)+ terminal.wait('initial real TUI attach', lambda: server.attaches >= 1+ and bool(terminal.screen.text().strip()), server)+ terminal.send('RECONNECT_VERSION_PARITY')+ terminal.wait('ordinary prompt editor ready', lambda:+ 'RECONNECT_VERSION_PARITY' in terminal.screen.text(), server)+ terminal.send('\r')+ terminal.wait('initial turn settled through actual TUI subscription', lambda:+ 'Fixture settled 1' in terminal.screen.text(), server)+ server.restart(daemon)+ terminal.wait('reattach banner rendered', lambda: server.post_close_attached+ and 'Daemon restarted (v' in terminal.screen.text(), server)+ screen = terminal.screen.text()+ actual_advice = 'restart the window to pick up the update.' in screen+ # This explicitly documents the baseline TS defect corrected by #3566.+ expected_advice = name == 'newer' or (kind == 'ts' and name == 'numeric_prerelease')+ assert actual_advice == expected_advice, (kind, name, screen)+ if name == 'same':+ expected = f'Daemon restarted (v{daemon}) - reconnected'+ elif expected_advice:+ expected = (f'Daemon restarted (v{daemon}), this window still runs v{client} '+ '- restart the window to pick up the update.')+ else:+ expected = f'Daemon restarted (v{daemon}), this window runs v{client}.'+ # Reflow is terminal layout only; all rendered cells and raw bytes are retained.+ assert expected in ' '.join(screen.split()), (expected, screen)+ observed.update({'daemon_version': daemon, 'client_version': client,+ 'restart_advice': actual_advice, 'expected_banner': expected,+ 'screen': screen, 'raw_ansi': terminal.raw.decode('utf-8', 'replace'),+ 'wire_commands': server.commands, 'executed': True})+ return observed+ except Exception as error:+ observed['error'] = f'{type(error).__name__}: {error}'+ raise+ finally:+ server.release_catalog.set()+ observed['resync_catalog_held'] = server.catalog_held.is_set()+ observed['wire_commands'] = list(server.commands)+ observed['fixture_errors'] = list(server.errors)+ observed['post_close_attached'] = server.post_close_attached+ observed['socket_connection_count'] = len(server.sockets)+ observed['diagnostic_logs'] = {str(path.relative_to(root)): path.read_text(errors='replace')[-12000:]+ for path in (root / 'agent/logs').glob('*.log')}+ if terminal is not None:+ observed['screen'] = terminal.screen.text()+ observed['raw_ansi'] = terminal.raw.decode('utf-8', 'replace')+ if terminal is not None:+ terminal.close()+ server.close()+++def main():+ parser = argparse.ArgumentParser()+ parser.add_argument('--receipt', required=True)+ args = parser.parse_args()+ receipt = {'scenario': 'reconnect_version', 'ts_archive_expected_sha256': TS_ARCHIVE_SHA256,+ 'fixture': 'Announced shutdown/session_closed, durable attach/list identity, successor hello; ordinary resync command catalog response held until actual banner capture.',+ 'scope': 'Actual rendered version advice; not restart durability or uninterrupted banner visibility.',+ 'intentional_difference': 'TS interprets numeric prerelease -20 as a release segment; Rust correctly treats it as older than the release.',+ 'observations': {}, 'passed': False}+ try:+ receipt['ts_archive_sha256'] = digest(Path(os.environ['PA_TS_ARCHIVE']))+ assert receipt['ts_archive_sha256'] == TS_ARCHIVE_SHA256+ with tempfile.TemporaryDirectory(prefix='pa-reconnect-parity-', dir='/tmp') as temp:+ for kind, variable in (('ts', 'PA_TS_BINARY'), ('rust', 'PA_RUST_BINARY')):+ binary = Path(os.environ[variable]).resolve()+ root = Path(temp) / kind+ root.mkdir()+ env = env_for(root, kind)+ client = runtime_version(binary, root, env)+ # Fixture expects current stable binaries; prerelease algorithm edges+ # are separately covered by red-first exact production-module tests.+ assert '-' not in client and '+' not in client, client+ hello = actual_hello(binary, root, env)+ receipt['observations'][kind] = {'binary_sha256': digest(binary),+ 'actual_hello': hello, 'client_version': client,+ 'cases': {}}+ for name in ('same', 'newer', 'older', 'metadata', 'numeric_prerelease'):+ observed = receipt['observations'][kind]['cases'][name] = {}+ run_case(kind, binary, root / name, hello, client, name, observed)+ ts, rust = (receipt['observations'][kind]['cases'] for kind in ('ts', 'rust'))+ for name in ('same', 'newer', 'older', 'metadata'):+ assert ts[name]['restart_advice'] == rust[name]['restart_advice'], name+ assert ts['numeric_prerelease']['restart_advice'] is True+ assert rust['numeric_prerelease']['restart_advice'] is False+ receipt['passed'] = True+ except Exception as error:+ receipt['error'] = f'{type(error).__name__}: {error}'+ Path(args.receipt).parent.mkdir(parents=True, exist_ok=True)+ Path(args.receipt).write_text(json.dumps(receipt, indent=2) + '\n')+ print(json.dumps({'scenario': receipt['scenario'], 'passed': receipt['passed'],+ 'error': receipt.get('error')}))+ return 0 if receipt['passed'] else 1+++if __name__ == '__main__':+ raise SystemExit(main())diff --git a/scripts/test_review_reconnect_version_parity.py b/scripts/test_review_reconnect_version_parity.pynew file mode 100644index 0000000000..2e6c6609ab--- /dev/null+++ b/scripts/test_review_reconnect_version_parity.py@@ -0,0 +1,116 @@+#!/usr/bin/env python3+"""Check the restart fixture's durable identity and observable resync gate."""+import json+from pathlib import Path+import socket+import threading+import tempfile+import unittest++from review_reconnect_version_parity import RestartSupervisor+++class Connection:+ def __init__(self, descriptor=4):+ self.descriptor = descriptor+ self.frames = []+ self.shutdowns = []++ def fileno(self):+ return self.descriptor++ def sendall(self, data):+ self.frames.append(json.loads(data))++ def shutdown(self, how):+ self.shutdowns.append(how)+++def fixture():+ server = object.__new__(RestartSupervisor)+ server.root = Path('/tmp/reconnect-fixture')+ server.closed = False+ server.hello = {'appVersion': '0.9.8', 'protocol': {'version': 7}}+ server.lock = threading.Lock()+ server.sockets = []+ server.release_catalog = threading.Event()+ server.catalog_held = threading.Event()+ return server+++class RestartFixtureTests(unittest.TestCase):+ def test_snapshot_reads_preserve_the_settled_fixture_turn(self):+ with tempfile.TemporaryDirectory(prefix='reconnect-read-', dir='/tmp') as folder:+ root = Path(folder)+ server = RestartSupervisor(root / 'd.sock',+ {'type': 'daemon_hello', 'protocol': {'name': 'prime-agent.daemon', 'version': 7}},+ 'restart', root)+ try:+ server.prompts.append({'message': 'persisted fixture prompt'})+ server.settle(Connection(), 's1', ('fixture', 'turn'), 1, emit=False)+ with socket.socket(socket.AF_UNIX) as connection:+ connection.settimeout(2)+ connection.connect(str(server.path))+ with connection.makefile('rb') as stream:+ self.assertEqual(json.loads(stream.readline())['type'], 'daemon_hello')+ for ident, command, expected in (+ ('1', 'get_messages', {'messages': server.messages}),+ ('2', 'get_session_context', {'context': {+ 'messages': server.messages, 'thinkingLevel': 'off',+ 'serviceTier': None, 'model': None}}),+ ):+ envelope = {'type': 'command', 'id': ident,+ 'command': {'type': command, 'activeSessionId': 's1'}}+ connection.sendall((json.dumps(envelope) + '\n').encode())+ response = json.loads(stream.readline())+ self.assertTrue(response['success'], response)+ self.assertEqual(response['data'], expected)+ self.assertEqual(len(server.messages), 2)+ self.assertEqual(server.errors, [])+ finally:+ server.close()++ def test_attach_and_list_share_the_durable_session_identity(self):+ server, connection = fixture(), Connection()+ server.send(connection, {'type': 'response', 'command': 'attach',+ 'data': {'snapshot': {'summary': {'id': 's1'}, 'state': {'sessionId': 'fixture-durable'}}}})+ server.send(connection, {'type': 'response', 'command': 'list', 'data': {'sessions': []}})+ attached = connection.frames[0]['data']['snapshot']['summary']+ listed = connection.frames[1]['data']['sessions'][0]+ self.assertEqual(attached, listed)+ self.assertEqual(attached['sessionId'], 'fixture-durable')+ self.assertEqual(attached['activeSessionId'], 's1')+ self.assertTrue(attached['sessionFile'].endswith('/sessions/fixture.jsonl'))++ def test_restart_announces_shutdown_before_closing_only_live_connections(self):+ server = fixture()+ live, closed = Connection(), Connection(-1)+ server.sockets = [live, closed]+ server.restart('0.10.0')+ self.assertEqual(live.frames, [+ {'type': 'daemon_closing', 'reason': 'shutdown'},+ {'type': 'session_closed', 'activeSessionId': 's1', 'reason': 'shutdown'}])+ self.assertEqual(live.shutdowns, [socket.SHUT_RDWR])+ self.assertEqual(closed.frames, [])+ self.assertEqual(server.hello['appVersion'], '0.10.0')+ self.assertEqual(server.hello['protocol'], {'version': 7})+ self.assertTrue(server.hello['supervisorGeneration'])++ def test_restarted_catalog_response_waits_for_capture_release(self):+ server, connection = fixture(), Connection()+ server.closed = True+ response = {'type': 'response', 'command': 'get_commands', 'data': {'commands': []}}+ thread = threading.Thread(target=server.send, args=(connection, response), daemon=True)+ thread.start()+ try:+ self.assertTrue(server.catalog_held.wait(2))+ self.assertEqual(connection.frames, [])+ finally:+ server.release_catalog.set()+ thread.join(2)+ self.assertFalse(thread.is_alive())+ self.assertEqual(connection.frames, [response])+++if __name__ == '__main__':+ unittest.main()