A self-improving RLM agent for coding workflows and long-running autonomous tasks.
Rust
fix: thread shellCommandPrefix, serper key, and PYTHONUTF8 into the kernel env (#3571)
Sebastian Müllerbd0790ac52f5
diff --git a/crates/pa-core/src/kernel/bootstrap/venv.rs b/crates/pa-core/src/kernel/bootstrap/venv.rsindex 9ff8e29421..d08bf97131 100644--- a/crates/pa-core/src/kernel/bootstrap/venv.rs+++ b/crates/pa-core/src/kernel/bootstrap/venv.rs@@ -84,6 +84,11 @@ async fn run_async(command: &str, args: &[String]) -> anyhow::Result<()> {child.args(&args).stdin(Stdio::null());// Hidden window on Windows (TS `spawnHidden`).crate::platform::process::set_no_window(&mut child);+ // CPython must read UTF-8 .pth files even under a Windows legacy+ // code page (TS bootstrap.ts:429).+ if cfg!(windows) {+ child.env("PYTHONUTF8", "1");+ }let status = child.status().with_context(|| format!("failed to spawn {command}"))?;diff --git a/crates/pa-core/src/kernel/bootstrap/venv/probe.rs b/crates/pa-core/src/kernel/bootstrap/venv/probe.rsindex aa678ce285..2ed2c23687 100644--- a/crates/pa-core/src/kernel/bootstrap/venv/probe.rs+++ b/crates/pa-core/src/kernel/bootstrap/venv/probe.rs@@ -19,6 +19,9 @@ fn run_quiet(command: &str, args: &[&str]) -> bool {.stderr(Stdio::null());// Hidden window on Windows (TS `spawnHidden`).crate::platform::process::set_no_window(&mut child);+ if cfg!(windows) {+ child.env("PYTHONUTF8", "1");+ }matches!(child.status(), Ok(status) if status.success())}diff --git a/crates/pa-core/src/kernel/manager/startup.rs b/crates/pa-core/src/kernel/manager/startup.rsindex 669c7247e2..57bb1deadb 100644--- a/crates/pa-core/src/kernel/manager/startup.rs+++ b/crates/pa-core/src/kernel/manager/startup.rs@@ -163,16 +163,7 @@ impl Inner {return Err(anyhow!("Kernel was disposed during startup"));}- // bash.py journals its process groups under this pid so the host can- // reap them if the runtime dies without running its shutdown hook.- let mut env: HashMap<String, String> = std::env::vars().collect();- for (key, value) in &self.options.env {- env.insert(key.clone(), value.clone());- }- env.insert(- "PRIME_AGENT_KERNEL_OWNER_PID".to_string(),- std::process::id().to_string(),- );+ let env = kernel_spawn_env(&self.options.env);let cwd = self.options.cwd.clone();let mut command = tokio::process::Command::new(&python);command@@ -533,6 +524,26 @@ impl Inner {}}+/// The kernel child's env (TS repl-manager.ts:374-385): the worker env plus+/// the provisioner's env, with UTF-8 mode forced on Windows (`CPython` must+/// read UTF-8 regardless of the active legacy code page, overriding any+/// provisioner-provided `PYTHONUTF8`) and the owner pid the runtime journals+/// its process groups under.+fn kernel_spawn_env(options_env: &HashMap<String, String>) -> HashMap<String, String> {+ let mut env: HashMap<String, String> = std::env::vars().collect();+ for (key, value) in options_env {+ env.insert(key.clone(), value.clone());+ }+ if cfg!(windows) {+ env.insert("PYTHONUTF8".to_string(), "1".to_string());+ }+ env.insert(+ "PRIME_AGENT_KERNEL_OWNER_PID".to_string(),+ std::process::id().to_string(),+ );+ env+}+#[cfg(unix)]fn unix_signal_of(status: std::process::ExitStatus) -> Option<i32> {crate::platform::process::termination_signal(&status)@@ -555,6 +566,19 @@ mod tests {dir}+ #[cfg(windows)]+ #[test]+ fn kernel_spawn_env_forces_utf8_mode() {+ let mut options_env = HashMap::new();+ options_env.insert("PYTHONUTF8".to_string(), "0".to_string());+ let env = kernel_spawn_env(&options_env);+ assert_eq!(env.get("PYTHONUTF8").map(String::as_str), Some("1"));+ assert_eq!(+ env.get("PRIME_AGENT_KERNEL_OWNER_PID").map(String::as_str),+ Some(std::process::id().to_string().as_str())+ );+ }+#[test]fn kernel_stderr_log_is_owner_only() {let root = temp_root("create");diff --git a/crates/pa-core/src/kernel/provisioner.rs b/crates/pa-core/src/kernel/provisioner.rsindex 8ffd6e7b82..0d7573e2bb 100644--- a/crates/pa-core/src/kernel/provisioner.rs+++ b/crates/pa-core/src/kernel/provisioner.rs@@ -1361,6 +1361,83 @@ mod tests {assert_eq!(engine.provisioner.inner.options.shell_path, Some(project));}+ #[tokio::test]+ async fn session_settings_reach_the_kernel_command_prefix() {+ let dir = tempfile::tempdir().unwrap();+ let agent_dir = dir.path().join("agent");+ let cwd = dir.path().join("project");+ std::fs::create_dir_all(&agent_dir).unwrap();+ std::fs::create_dir_all(cwd.join(".prime/agent")).unwrap();+ std::fs::write(+ agent_dir.join("settings.json"),+ serde_json::json!({ "shellCommandPrefix": "shopt -s expand_aliases" }).to_string(),+ )+ .unwrap();+ let engine = shell_test_session(cwd, agent_dir).await.unwrap();+ assert_eq!(+ engine.provisioner.inner.options.command_prefix.as_deref(),+ Some("shopt -s expand_aliases")+ );+ }++ #[tokio::test]+ async fn a_stored_serper_key_reaches_the_kernel_env() {+ let dir = tempfile::tempdir().unwrap();+ let agent_dir = dir.path().join("agent");+ let cwd = dir.path().join("project");+ std::fs::create_dir_all(&agent_dir).unwrap();+ std::fs::create_dir_all(cwd.join(".prime/agent")).unwrap();+ std::fs::write(+ agent_dir.join("auth.json"),+ r#"{ "serper": { "type": "api_key", "key": "!printf key-from-cmd" } }"#,+ )+ .unwrap();+ let engine = shell_test_session(cwd, agent_dir).await.unwrap();+ let injected = engine+ .provisioner+ .inner+ .options+ .env+ .get("SERPER_API_KEY")+ .map(String::as_str);+ // A nonblank ambient SERPER_API_KEY wins (TS parity): the ambient key+ // reaches the kernel through the inherited env, not the wiring.+ if std::env::var("SERPER_API_KEY").is_ok_and(|value| !value.trim().is_empty()) {+ assert_eq!(injected, None);+ } else {+ assert_eq!(injected, Some("key-from-cmd"));+ }+ }++ #[tokio::test]+ async fn without_a_websearch_skill_no_serper_key_env() {+ let dir = tempfile::tempdir().unwrap();+ let agent_dir = dir.path().join("agent");+ let cwd = dir.path().join("project");+ std::fs::create_dir_all(&agent_dir).unwrap();+ std::fs::create_dir_all(cwd.join(".prime/agent")).unwrap();+ std::fs::write(+ agent_dir.join("settings.json"),+ serde_json::json!({ "bundledSkills": { "websearch": false } }).to_string(),+ )+ .unwrap();+ std::fs::write(+ agent_dir.join("auth.json"),+ r#"{ "serper": { "type": "api_key", "key": "!printf key-from-cmd" } }"#,+ )+ .unwrap();+ let engine = shell_test_session(cwd, agent_dir).await.unwrap();+ assert!(+ !engine+ .provisioner+ .inner+ .options+ .env+ .contains_key("SERPER_API_KEY"),+ "the key rides the env only when a websearch skill is loaded"+ );+ }+#[tokio::test]async fn session_settings_reject_a_missing_shell_path() {let dir = tempfile::tempdir().unwrap();diff --git a/crates/pa-core/src/session_engine/engine.rs b/crates/pa-core/src/session_engine/engine.rsindex 800b5a8154..f8aed98949 100644--- a/crates/pa-core/src/session_engine/engine.rs+++ b/crates/pa-core/src/session_engine/engine.rs@@ -216,6 +216,12 @@ pub async fn create_session(mut config: SessionEngineConfig) -> anyhow::Result<Ssettings.settings().shell_path.as_deref(),)?.map(std::path::PathBuf::from);+ // TS injects the prefix only when truthy (an empty string stays unset).+ let kernel_command_prefix = settings+ .settings()+ .shell_command_prefix+ .clone()+ .filter(|prefix| !prefix.is_empty());let traces = session_manager.is_persisted().then(|| {@@ -435,6 +441,26 @@ pub async fn create_session(mut config: SessionEngineConfig) -> anyhow::Result<S)as crate::kernel::provisioner::UnavailableSkillsCallback)};+ // TS resolves the serper credential on the host: `!command` key refs+ // cannot run in-kernel (the websearch skill's auth.json fallback reads+ // literals and env-var names, not commands). The credential is read+ // under the auth lock, then resolved off the async runtime (a `!command`+ // key can block).+ let serper_api_key = {+ let credential = {+ let auth = mcp_manager.lock().unwrap().auth_storage_handle();+ let guard = auth.lock().await;+ guard+ .get_all()+ .credential(crate::auth::SERPER_CREDENTIAL_ID)+ };+ let skills = resources.skills.clone();+ tokio::task::spawn_blocking(move || {+ super::runtime_wiring::websearch_api_key(&skills, credential)+ })+ .await+ .map_err(|join| anyhow::anyhow!("websearch key resolve join failed: {join}"))?+ };let provisioner = super::runtime_wiring::kernel_provisioner(session_id,handlers,@@ -442,6 +468,8 @@ pub async fn create_session(mut config: SessionEngineConfig) -> anyhow::Result<Scwd.clone(),&config.agent_dir,kernel_shell_path,+ kernel_command_prefix,+ serper_api_key,session_artifact_dir,on_restore,config.on_background_work_settled.clone(),diff --git a/crates/pa-core/src/session_engine/runtime_wiring.rs b/crates/pa-core/src/session_engine/runtime_wiring.rsindex 31165418e0..8215905fa8 100644--- a/crates/pa-core/src/session_engine/runtime_wiring.rs+++ b/crates/pa-core/src/session_engine/runtime_wiring.rs@@ -223,6 +223,8 @@ pub fn kernel_provisioner(cwd: std::path::PathBuf,agent_dir: &std::path::Path,shell_path: Option<std::path::PathBuf>,+ command_prefix: Option<String>,+ serper_api_key: Option<String>,session_artifact_dir: Option<std::path::PathBuf>,on_restore: Option<crate::kernel::provisioner::RestoreCallback>,on_background_work_settled: Option<crate::kernel::shared::BackgroundWorkSettledCallback>,@@ -245,12 +247,15 @@ pub fn kernel_provisioner(env.insert(key.to_string(), value.to_string_lossy().to_string());}}+ if let Some(serper_api_key) = serper_api_key {+ env.insert("SERPER_API_KEY".to_string(), serper_api_key);+ }Arc::new(KernelProvisioner::new(cwd,IpythonKernelProvisionerOptions {python: None,env,- command_prefix: None,+ command_prefix,shell_path,session_id: Some(session_id),host_handlers: handlers,@@ -267,6 +272,34 @@ pub fn kernel_provisioner())}+/// TS `_addWebsearchKeyEnv` (agent-session.ts:11137-11158): the serper key+/// rides the kernel env only when a websearch skill is loaded, the ambient+/// env does not already carry one, and the stored `serper` credential is an+/// api key that resolves non-empty. The websearch skill's own `!command`+/// key refs cannot resolve in-kernel, so the host resolves them here; the+/// caller reads the credential and runs this off the async runtime, because+/// a `!command` key can block.+#[must_use]+pub(crate) fn websearch_api_key(+ skills: &[Skill],+ credential: Option<crate::auth::AuthCredential>,+) -> Option<String> {+ if std::env::var("SERPER_API_KEY").is_ok_and(|value| !value.trim().is_empty()) {+ return None;+ }+ if !skills.iter().any(|skill| skill.name == "websearch") {+ return None;+ }+ match credential {+ Some(crate::auth::AuthCredential::ApiKey { key, .. }) => {+ crate::auth::resolve_config_value::resolve_config_value(&key)+ .map(|value| value.trim().to_string())+ .filter(|value| !value.is_empty())+ }+ _ => None,+ }+}+impl IpythonKernelProvisioner for KernelProvisioner {fn ensure(&self,diff --git a/scripts/review_kernel_env_parity.py b/scripts/review_kernel_env_parity.pynew file mode 100644index 0000000000..2eae95a658--- /dev/null+++ b/scripts/review_kernel_env_parity.py@@ -0,0 +1,459 @@+#!/usr/bin/env python3+"""Actual pinned TS/Rust REPL comparison for bash prefix and Serper wiring.++Only synthetic credentials and loopback provider traffic. The same Python cell+reads the kernel env and runs the real bash() helper. Windows PYTHONUTF8 is not+verified by this Linux comparison; the separate Windows test is cross-compiled.+"""+import argparse+import http.server+import json+import os+from pathlib import Path+import shlex+import signal+import subprocess+import time+import sys+import tempfile+import threading++from review_restore_notice_parity import texts, Server, sha256, TS_ARCHIVE_SHA256+from review_draft_disconnect_parity import stop+from review_agent_bounce_parity import Client as BounceClient++MARKER = 'KERNEL_ENV_PARITY='+LIMIT = 35+CODE = '''import os, json+shell = await bash("printf '%s' \\"${PA_PREFIX_SENTINEL:-ABSENT}\\"")+print('KERNEL_ENV_PARITY=' + json.dumps({'serper': os.environ.get('SERPER_API_KEY'),+ 'prefix': os.environ.get('PRIME_AGENT_BASH_COMMAND_PREFIX'),+ 'bash_output': shell.output, 'bash_exit': shell.exit_code}))'''+CASES = {+ 'command_key_and_prefix': {'skill': True, 'ambient': None, 'prefix': 'export PA_PREFIX_SENTINEL=prefix-ran'},+ 'ambient_key_wins': {'skill': True, 'ambient': ' ambient-fixture ', 'prefix': ''},+ 'no_skill_no_command': {'skill': False, 'ambient': None, 'prefix': ''},+ 'blank_ambient_resolves': {'skill': True, 'ambient': ' ', 'prefix': ''},+}+++class Handler(http.server.BaseHTTPRequestHandler):+ def log_message(self, *_args):+ pass++ def do_POST(self):+ if self.path != '/v1/chat/completions':+ self.send_error(404)+ return+ body = json.loads(self.rfile.read(int(self.headers['Content-Length'])))+ requests = self.server.requests[self.server.phase]+ requests.append(body)+ if len(requests) == 1:+ offered = {tool.get('function', {}).get('name') for tool in body.get('tools', [])}+ name = next((name for name in ('python_repl', 'ipython') if name in offered), None)+ if name is None:+ self.send_error(422, 'missing offered REPL tool')+ return+ delta = {'tool_calls': [{'index': 0, 'id': 'kernel_' + self.server.phase,+ 'type': 'function', 'function': {'name': name, 'arguments': json.dumps({'code': CODE})}}]}+ finish = 'tool_calls'+ else:+ delta, finish = {'content': 'Kernel environment fixture complete.'}, 'stop'+ def chunk(delta, reason=None):+ return {'id': 'kernel-env', 'object': 'chat.completion.chunk', 'created': 1,+ 'model': 'env-fixture', 'choices': [{'index': 0, 'delta': delta, 'finish_reason': reason}]}+ wire = ''.join('data: ' + json.dumps(item) + '\n\n' for item in (+ chunk({'role': 'assistant', **delta}), chunk({}, finish))) + 'data: [DONE]\n\n'+ self.send_response(200)+ self.send_header('Content-Type', 'text/event-stream')+ self.send_header('Content-Length', str(len(wire.encode())))+ self.end_headers()+ self.wfile.write(wire.encode())+++def current_probe(requests, phase):+ assert len(requests) == 2, 'unexpected provider sequence'+ results = [message for message in requests[-1]['messages'] if message.get('role') == 'tool'+ and message.get('tool_call_id') == 'kernel_' + phase]+ assert len(results) == 1, 'missing/duplicate current tool result'+ probes = [json.loads(line[len(MARKER):]) for text in texts(results[0].get('content'))+ for line in text.splitlines() if line.startswith(MARKER)]+ assert len(probes) == 1, 'missing/duplicate current kernel probe'+ return probes[0]+++def expected(case):+ key = case['ambient']+ if case['skill'] and (key is None or not key.strip()):+ key = 'resolved-fixture-key'+ prefix = case['prefix'] or None+ return {'serper': key, 'prefix': prefix,+ 'bash_output': 'prefix-ran' if prefix else 'ABSENT', 'bash_exit': 0}+++def owned_kernel(pid, owner, fixture, identity=None):+ try:+ current, state = process_identity(pid)+ if state == 'Z' or (identity is not None and current != identity):+ return None+ env = dict(item.split(b'=', 1) for item in Path('/proc/%d/environ' % pid).read_bytes().split(b'\0') if b'=' in item)+ if (env.get(b'PRIME_AGENT_KERNEL_OWNER_PID') != str(owner).encode()+ or env.get(b'PA_KERNEL_ENV_FIXTURE_ID') != fixture.encode()):+ return None+ command = Path('/proc/%d/cmdline' % pid).read_bytes().split(b'\0')+ if not command or not command[0] or b'python' not in Path(command[0].decode()).name.encode():+ return None+ return current+ except (OSError, ValueError, UnicodeError):+ return None+++def process_identity(pid):+ stat = Path('/proc/%d/stat' % pid).read_text()+ fields = stat[stat.rfind(')') + 2:].split()+ return 'proc:' + fields[19], fields[0]+++def worker_descriptor(agent, active, socket_path, deadline=None, previous=None):+ deadline = deadline or time.monotonic() + LIMIT+ while time.monotonic() < deadline:+ candidates = list((agent / 'daemon-workers').rglob('*.json'))+ for path in candidates:+ try:+ row = json.loads(path.read_text())+ pid = row.get('pid')+ if (row.get('rootActiveSessionId') == active+ and row.get('supervisorSocketPath') == str(socket_path)+ and isinstance(pid, int) and pid > 0 and pid != previous):+ return path, row+ except (OSError, ValueError):+ pass # Atomic/transitional descriptor writes are not readiness.+ threading.Event().wait(0.025)+ raise AssertionError('fixture worker descriptor never reached readiness')+++def verify_worker(row, active, binary, socket_path):+ pid = row['pid']+ assert row.get('rootActiveSessionId') == active, 'wrong descriptor identity'+ assert row.get('supervisorSocketPath') == str(socket_path), 'wrong supervisor descriptor'+ command = Path('/proc/%d/cmdline' % pid).read_bytes().split(b'\0')+ assert command[0] == str(binary).encode(), 'worker argv0 is not fixture binary'+ env = dict(item.split(b'=', 1) for item in Path('/proc/%d/environ' % pid).read_bytes().split(b'\0') if b'=' in item)+ for key, value in {+ 'PRIME_AGENT_INTERNAL_DAEMON_WORKER': '1',+ 'PRIME_AGENT_INTERNAL_DAEMON_WORKER_ACTIVE_SESSION_ID': active,+ 'PRIME_AGENT_INTERNAL_DAEMON_SUPERVISOR_SOCKET': str(socket_path),+ }.items():+ assert env.get(key.encode()) == value.encode(), 'wrong fixture worker env identity'+ worker_socket = str(row['socketPath']).encode()+ assert (worker_socket in command or env.get(b'PRIME_AGENT_INTERNAL_DAEMON_WORKER_SOCKET') == worker_socket), 'wrong worker socket identity'+ identity, state = process_identity(pid)+ assert row.get('processStartId') == identity and state != 'Z', 'wrong/reused worker PID'+ return pid, identity+++def wait_gone(identities):+ deadline = time.monotonic() + LIMIT+ while time.monotonic() < deadline:+ alive = []+ for pid, identity in identities:+ try:+ current, state = process_identity(pid)+ if current == identity and state != 'Z':+ alive.append(pid)+ except FileNotFoundError:+ pass+ if not alive:+ return+ threading.Event().wait(0.025)+ raise AssertionError('owned fixture processes remained after shutdown: ' + str(alive))++++def finish_daemon(client, process):+ client.call('shutdown', force=True)+ client.close()+ process.wait(timeout=15)+ assert process.returncode == 0, 'fixture supervisor failed graceful shutdown'+++class KernelClient(BounceClient):+ """Same daemon frames, with an explicit cold-kernel request budget."""+ def call(self, kind, timeout_seconds=LIMIT, **payload):+ self.counter += 1+ ident = str(self.counter)+ envelope = {'type': 'command', 'id': ident,+ 'protocol': {'name': 'prime-agent.daemon', 'version': 7},+ 'command': {'type': kind, **payload}}+ deadline = time.monotonic() + timeout_seconds+ previous_timeout = self.sock.gettimeout()+ try:+ self.sock.settimeout(timeout_seconds)+ self.sock.sendall((json.dumps(envelope) + '\n').encode())+ while time.monotonic() < deadline:+ self.sock.settimeout(max(0.001, deadline - time.monotonic()))+ line = self.reader.readline()+ assert line, 'daemon closed connection'+ response = json.loads(line)+ self.wire.append(response)+ if response.get('type') == 'response' and response.get('id') == ident:+ assert response.get('success'), response+ return response.get('data')+ raise TimeoutError('command never answered: ' + kind)+ finally:+ self.sock.settimeout(previous_timeout)+++def signal_owned(pid, identity, validator, signum):+ """Pin the PID with a pidfd, then recheck exact ownership before signaling."""+ try:+ fd = os.pidfd_open(pid)+ except ProcessLookupError:+ return False+ try:+ current, state = process_identity(pid)+ if current != identity or state == 'Z' or not validator():+ return False+ signal.pidfd_send_signal(fd, signum)+ return True+ except ProcessLookupError:+ return False+ finally:+ os.close(fd)+++def live_identities(identities):+ alive = set()+ for pid, identity in identities:+ try:+ current, state = process_identity(pid)+ if current == identity and state != 'Z':+ alive.add((pid, identity))+ except FileNotFoundError:+ pass+ return alive+++def reap_leftovers(agent, binary, socket_path, descriptor, kernels, worker_pid, fixture, observation):+ """Best-effort exact-owned fallback; never clears the graceful-cleanup failure."""+ rows = [descriptor] if descriptor is not None else []+ for path in (agent / 'daemon-workers').rglob('*.json'):+ try:+ row = json.loads(path.read_text())+ if row.get('supervisorSocketPath') == str(socket_path):+ rows.append(row)+ except (OSError, ValueError):+ pass+ targets = {}+ owner_ids = {worker_pid} if worker_pid is not None else set()+ errors = observation['fallback_errors'] = []+ for row in rows:+ try:+ pid, identity = verify_worker(row, row['rootActiveSessionId'], binary, socket_path)+ owner_ids.add(pid)+ def valid_worker(row=row, pid=pid, identity=identity):+ try:+ return verify_worker(row, row['rootActiveSessionId'], binary, socket_path) == (pid, identity)+ except (OSError, AssertionError):+ return False+ targets[(pid, identity)] = valid_worker+ except (OSError, AssertionError, KeyError) as error:+ errors.append('worker ownership unavailable: ' + str(error))+ # Discover kernels even if the turn failed before the regular tracker saw+ # them, requiring the unique fixture tag and a verified fixture worker owner.+ for entry in Path('/proc').iterdir():+ if entry.name.isdigit():+ pid = int(entry.name)+ for owner in owner_ids:+ identity = owned_kernel(pid, owner, fixture, kernels.get(pid))+ if identity:+ kernels[pid] = identity+ targets[(pid, identity)] = lambda pid=pid, owner=owner, identity=identity: \+ owned_kernel(pid, owner, fixture, identity) == identity+ break+ observation['fallback_signals'] = []+ known_identities = set(targets) | set(kernels.items())+ if descriptor is not None and descriptor.get('processStartId'):+ known_identities.add((descriptor['pid'], descriptor['processStartId']))+ for signum in (signal.SIGTERM, signal.SIGKILL):+ for (pid, identity), validator in targets.items():+ try:+ if signal_owned(pid, identity, validator, signum):+ observation['fallback_signals'].append({'pid': pid, 'signal': signum.name})+ except OSError as error:+ errors.append('owned signal failed: ' + str(error))+ deadline = time.monotonic() + (3 if signum == signal.SIGTERM else 2)+ remaining = live_identities(known_identities)+ while time.monotonic() < deadline:+ remaining = live_identities(known_identities)+ if not remaining:+ observation['fallback_processes_exited'] = True+ return+ threading.Event().wait(0.025)+ observation['fallback_processes_exited'] = False+ observation['fallback_remaining'] = sorted(remaining)+++def run_case(binary, label, name, case, root, observation):+ for directory in ('home', 'tmp', 'work', 'agent', 'sessions'):+ (root / directory).mkdir(parents=True)+ agent, cwd = root / 'agent', root / 'work'+ env = {key: os.environ[key] for key in ('PATH', 'LANG', 'LC_ALL', 'TZ',+ 'PRIME_AGENT_KERNEL_PYTHON', 'PA_E2E_KERNEL_PYTHON') if key in os.environ}+ library = Path(os.environ['PI_PACKAGE_DIR'])+ if label == 'ts':+ env['PI_PACKAGE_DIR'] = str(library)+ env['PYTHONPATH'] = os.pathsep.join(str(path) for path in sorted((library / 'skills').glob('*/src')))+ env.update(HOME=str(root / 'home'), TMPDIR=str(root / 'tmp'), DO_NOT_TRACK='1', PI_OFFLINE='1',+ PI_CODING_AGENT_DIR=str(agent), PRIME_AGENT_CODING_AGENT_DIR=str(agent),+ PI_SESSION_DIR=str(root / 'sessions'), PRIME_AGENT_SESSION_DIR=str(root / 'sessions'),+ XDG_CONFIG_HOME=str(root / 'config'), XDG_CACHE_HOME=str(root / 'cache'), XDG_DATA_HOME=str(root / 'data'))+ env['PA_KERNEL_ENV_FIXTURE_ID'] = str(root.resolve())+ if case['ambient'] is not None:+ env['SERPER_API_KEY'] = case['ambient']+ # Explicit identical custom skill avoids differences in bundled inventory.+ # Bundled websearch is disabled in every case; only this custom skill gates+ # injection, exercising the documented bundled-or-custom skill condition.+ if case['skill']:+ skill = agent / 'skills' / 'websearch' / 'SKILL.md'+ skill.parent.mkdir(parents=True)+ skill.write_text('---\nname: websearch\ndescription: Synthetic environment fixture\n---\nNo network work.\n')+ invoked = root / 'credential-command-invoked'+ command = "!printf ' resolved-fixture-key '; printf invoked > " + shlex.quote(str(invoked))+ (agent / 'auth.json').write_text(json.dumps({'serper': {'type': 'api_key', 'key': command}}))+ server = Server(root)+ server.RequestHandlerClass = Handler+ server.phase = name+ server.requests = {name: []}+ thread = threading.Thread(target=server.serve_forever, daemon=True)+ thread.start()+ (agent / 'models.json').write_text(json.dumps({'providers': {'fixture': {+ 'api': 'openai-completions', 'apiKey': 'fixture-only',+ 'baseUrl': 'http://127.0.0.1:%s/v1' % server.server_address[1],+ 'models': [{'id': 'env-fixture', 'name': 'Environment fixture', 'reasoning': False,+ 'contextWindow': 128000, 'maxTokens': 4096}]}}}))+ (agent / 'settings.json').write_text(json.dumps({'defaultProvider': 'fixture',+ 'defaultModel': 'env-fixture', 'prewarmPythonKernel': False,+ 'shellCommandPrefix': case['prefix'], 'bundledSkills': {'websearch': False}}))+ socket_path = root / 'd.sock'+ log = open(root / 'daemon.log', 'wb')+ process = subprocess.Popen([str(binary), '--mode', 'daemon', '--daemon-socket', str(socket_path)],+ cwd=cwd, env=env, stdout=log, stderr=subprocess.STDOUT, start_new_session=True)+ client = None+ tracker = None+ finished = threading.Event()+ kernels = {}+ tracked = set()+ primary_error = None+ worker_pid = None+ descriptor = None+ fixture = env['PA_KERNEL_ENV_FIXTURE_ID']+ try:+ client = KernelClient(socket_path, process)+ created = client.call('create', name='kernel-env-' + name, config={+ 'cwd': str(cwd), 'agentDir': str(agent), 'sessionDir': str(root / 'sessions'),+ 'provider': 'fixture', 'model': 'env-fixture', 'noExtensions': True,+ 'noContextFiles': True, 'telemetryDisabled': True})+ active = created.get('activeSessionId') or created.get('id')+ assert active, 'create omitted active identity'+ _, descriptor = worker_descriptor(agent, active, socket_path)+ worker_pid, worker_identity = verify_worker(descriptor, active, binary, socket_path)+ tracked.add((worker_pid, worker_identity))+ def discover():+ while not finished.is_set():+ for entry in Path('/proc').iterdir():+ if entry.name.isdigit():+ pid = int(entry.name)+ identity = owned_kernel(pid, worker_pid, fixture)+ if identity:+ kernels[pid] = identity+ finished.wait(0.025)+ tracker = threading.Thread(target=discover, daemon=True)+ tracker.start()+ # Raw daemon user input is identical in both products. This avoids TS's+ # CLI->daemon worker route vs Rust's in-process JSON route entirely.+ client.call('prompt_and_wait', timeout_seconds=90, activeSessionId=active, message='Run the kernel environment fixture cell.')+ observation['probe'] = current_probe(server.requests[name], name)+ assert observation['probe'] == expected(case), (observation['probe'], expected(case))+ ran = case['skill'] and (case['ambient'] is None or not case['ambient'].strip())+ assert invoked.exists() == ran, 'credential command ran outside its skill/ambient gate'+ observation['credential_command_ran'] = invoked.exists()+ assert kernels, 'successful fixture did not capture kernel ownership'+ except BaseException as error:+ primary_error = error+ observation['primary_error'] = str(error)+ raise+ finally:+ finished.set()+ if tracker:+ tracker.join(timeout=2)+ observation['owned_kernel_identities'] = dict(kernels)+ tracked.update(kernels.items())+ observation['requests'] = server.requests[name]+ cleanup_error = None+ try:+ assert client is not None, 'fixture did not establish cleanup control'+ observation['wire'] = client.wire+ finish_daemon(client, process) # Close after ack, before waiting for TS exit.+ wait_gone(tracked)+ assert tracker is None or not tracker.is_alive(), 'kernel tracker did not stop'+ observation['cleanup_verified'] = True+ except Exception as error:+ cleanup_error = error+ observation['cleanup_error'] = str(error)+ observation['cleanup_verified'] = False+ finally:+ if client:+ client.close()+ stop(process)+ if cleanup_error:+ try:+ reap_leftovers(agent, binary, socket_path, descriptor, kernels, worker_pid, fixture, observation)+ except Exception as error:+ observation['fallback_error'] = str(error)+ log.close()+ observation['daemon_log'] = (root / 'daemon.log').read_text(errors='replace')[-6000:]+ server.shutdown()+ server.server_close()+ thread.join(timeout=2)+ if cleanup_error and primary_error is None:+ raise AssertionError('fixture cleanup failed: ' + str(cleanup_error)) from cleanup_error+++def main():+ parser = argparse.ArgumentParser(description=__doc__)+ parser.add_argument('--receipt', type=Path, required=True)+ args = parser.parse_args()+ receipt = {'verified': False, 'runs': {}, 'scope': 'Identical raw daemon create/prompt_and_wait + actual REPL kernel env + real bash output; '+ 'command-backed credential, trimming, ambient precedence, custom skill gate, empty-prefix omission',+ 'not_verified': ['Windows PYTHONUTF8 behavior (cross-compiled Rust regression only)',+ 'TUI/JSON CLI sender routing; runtime settings reload of captured env'],+ 'normalization': 'Identical synthetic scalar results; legacy offered ipython/python_repl tool name selected per binary. Raw traffic retained.'}+ try:+ assert sys.platform == 'linux', 'requires hosted Linux binaries'+ assert sha256(os.environ['PA_TS_ARCHIVE']) == TS_ARCHIVE_SHA256, 'TS release archive mismatch'+ receipt['ts_archive_sha256'] = TS_ARCHIVE_SHA256+ with tempfile.TemporaryDirectory(prefix='kernel-env-parity-', dir='/tmp') as folder:+ for label in ('ts', 'rust'):+ binary = Path(os.environ['PA_' + label.upper() + '_BINARY']).resolve()+ run = receipt['runs'][label] = {'binary_sha256': sha256(binary), 'cases': {}}+ for name, case in CASES.items():+ observation = run['cases'][name] = {}+ try:+ run_case(binary, label, name, case, Path(folder) / label / name, observation)+ except Exception as error:+ observation['error'] = str(error)+ assert all('error' not in case for run in receipt['runs'].values() for case in run['cases'].values()), receipt['runs']+ for name in CASES:+ assert receipt['runs']['ts']['cases'][name]['probe'] == receipt['runs']['rust']['cases'][name]['probe']+ receipt['verified'] = True+ except Exception as error:+ receipt['error'] = str(error)+ args.receipt.parent.mkdir(parents=True, exist_ok=True)+ args.receipt.write_text(json.dumps(receipt, indent=2) + '\n')+ print(json.dumps({'verified': receipt['verified'], 'receipt': str(args.receipt), 'error': receipt.get('error')}))+ return 0 if receipt['verified'] else 1+++if __name__ == '__main__':+ sys.exit(main())diff --git a/scripts/test_review_kernel_env_parity.py b/scripts/test_review_kernel_env_parity.pynew file mode 100644index 0000000000..44300c1c0a--- /dev/null+++ b/scripts/test_review_kernel_env_parity.py@@ -0,0 +1,136 @@+#!/usr/bin/env python3+"""Prove stale tool text cannot satisfy a current kernel probe and cell quoting works."""+import ast+import asyncio+from types import SimpleNamespace+import unittest+import json+from pathlib import Path+import signal+from unittest.mock import patch, MagicMock+from review_kernel_env_parity import current_probe, CODE, MARKER, owned_kernel, finish_daemon, KernelClient, signal_owned, reap_leftovers+++def requests(content=None):+ messages = [{'role': 'tool', 'tool_call_id': 'kernel_old', 'content': MARKER + '{"old":true}'}]+ if content is not None:+ messages.append({'role': 'tool', 'tool_call_id': 'kernel_new', 'content': content})+ return [{}, {'messages': messages}]+++class ProbeTests(unittest.TestCase):+ def test_only_current_result_counts(self):+ self.assertEqual(current_probe(requests(MARKER + '{"new":true}'), 'new'), {'new': True})++ def test_old_probe_cannot_hide_failed_cell(self):+ with self.assertRaisesRegex(AssertionError, 'current kernel probe'):+ current_probe(requests('Traceback: failed current cell'), 'new')++ def test_old_probe_cannot_hide_missing_result(self):+ with self.assertRaisesRegex(AssertionError, 'current tool result'):+ current_probe(requests(), 'new')++ def test_duplicate_probe_is_failure(self):+ with self.assertRaisesRegex(AssertionError, 'current kernel probe'):+ current_probe(requests(MARKER + '{}\n' + MARKER + '{}'), 'new')++ def test_cell_passes_the_intended_bash_command(self):+ commands = []+ async def bash(command):+ commands.append(command)+ return SimpleNamespace(output='ABSENT', exit_code=0)+ compiled = compile(CODE, '<fixture-cell>', 'exec', flags=ast.PyCF_ALLOW_TOP_LEVEL_AWAIT)+ asyncio.run(eval(compiled, {'bash': bash, 'print': lambda *_args: None}))+ self.assertEqual(commands, ['printf \'%s\' "${PA_PREFIX_SENTINEL:-ABSENT}"'])++ def test_foreign_fixture_kernel_is_not_owned(self):+ env = b'PRIME_AGENT_KERNEL_OWNER_PID=123\0PA_KERNEL_ENV_FIXTURE_ID=/other-fixture\0'+ with patch('review_kernel_env_parity.process_identity', return_value=('proc:456', 'S')), \+ patch('pathlib.Path.read_bytes', return_value=env):+ self.assertIsNone(owned_kernel(789, 123, '/fixture'))++ def test_wrong_kernel_owner_is_not_owned(self):+ env = b'PRIME_AGENT_KERNEL_OWNER_PID=999\0PA_KERNEL_ENV_FIXTURE_ID=/fixture\0'+ with patch('review_kernel_env_parity.process_identity', return_value=('proc:456', 'S')), \+ patch('pathlib.Path.read_bytes', return_value=env):+ self.assertIsNone(owned_kernel(789, 123, '/fixture'))++ def test_recycled_kernel_pid_is_not_owned(self):+ with patch('review_kernel_env_parity.process_identity', return_value=('proc:new', 'S')):+ self.assertIsNone(owned_kernel(789, 123, '/fixture', 'proc:old'))++ def test_matching_kernel_owner_fixture_and_start_identity(self):+ env = b'PRIME_AGENT_KERNEL_OWNER_PID=123\0PA_KERNEL_ENV_FIXTURE_ID=/fixture\0'+ with patch('review_kernel_env_parity.process_identity', return_value=('proc:456', 'S')), \+ patch('pathlib.Path.read_bytes', side_effect=[env, b'/fixture/python3\0-m\0rlm.kernel\0']):+ self.assertEqual(owned_kernel(789, 123, '/fixture', 'proc:456'), 'proc:456')++ def test_shutdown_ack_then_control_close_then_process_exit(self):+ events = []+ client, process = MagicMock(), MagicMock(returncode=0)+ client.call.side_effect = lambda *a, **k: events.append('ack')+ client.close.side_effect = lambda: events.append('client_closed')+ process.wait.side_effect = lambda **k: events.append('process_exit')+ finish_daemon(client, process)+ self.assertEqual(events, ['ack', 'client_closed', 'process_exit'])++ def test_refused_shutdown_is_not_cleanup_success(self):+ client, process = MagicMock(), MagicMock(returncode=0)+ client.call.side_effect = AssertionError('refused')+ with self.assertRaisesRegex(AssertionError, 'refused'):+ finish_daemon(client, process)+ process.wait.assert_not_called()++ def test_cold_kernel_response_after_35_seconds_uses_request_budget(self):+ client = KernelClient.__new__(KernelClient)+ client.counter, client.wire = 0, []+ client.sock = MagicMock()+ client.sock.gettimeout.return_value = 35+ client.reader = MagicMock()+ client.reader.readline.return_value = json.dumps({'type': 'response', 'id': '1', 'success': True, 'data': {'done': True}}).encode()+ with patch('review_kernel_env_parity.time.monotonic', side_effect=[0, 36, 36]):+ self.assertEqual(client.call('prompt_and_wait', timeout_seconds=90), {'done': True})+ self.assertEqual([call.args[0] for call in client.sock.settimeout.call_args_list], [90, 54, 35])++ def test_recycled_pid_never_receives_fallback_signal(self):+ with patch('os.pidfd_open', return_value=42, create=True), patch('os.close'), \+ patch('review_kernel_env_parity.process_identity', return_value=('proc:new', 'S')), \+ patch('signal.pidfd_send_signal', create=True) as sent:+ self.assertFalse(signal_owned(789, 'proc:old', lambda: True, signal.SIGTERM))+ sent.assert_not_called()++ def test_failed_ownership_check_never_receives_fallback_signal(self):+ with patch('os.pidfd_open', return_value=42, create=True), patch('os.close'), \+ patch('review_kernel_env_parity.process_identity', return_value=('proc:456', 'S')), \+ patch('signal.pidfd_send_signal', create=True) as sent:+ self.assertFalse(signal_owned(789, 'proc:456', lambda: False, signal.SIGTERM))+ sent.assert_not_called()++ def test_fallback_signals_only_owned_kernel_and_preserves_red_status(self):+ observation = {'cleanup_error': 'graceful shutdown refused', 'cleanup_verified': False}+ with patch('pathlib.Path.rglob', return_value=[]), \+ patch('pathlib.Path.iterdir', return_value=[Path('/proc/789')]), \+ patch('review_kernel_env_parity.owned_kernel', return_value='proc:456'), \+ patch('review_kernel_env_parity.signal_owned', return_value=True) as sent, \+ patch('review_kernel_env_parity.live_identities', return_value=set()):+ reap_leftovers(Path('/fixture'), Path('/fixture/binary'), Path('/fixture/d.sock'),+ None, {789: 'proc:456'}, 123, '/fixture', observation)+ sent.assert_called_once()+ self.assertEqual(sent.call_args.args[:2], (789, 'proc:456'))+ self.assertTrue(observation['fallback_processes_exited'])+ self.assertEqual(observation['cleanup_error'], 'graceful shutdown refused')+ self.assertFalse(observation['cleanup_verified'])++ def test_foreign_kernel_never_becomes_fallback_target(self):+ with patch('pathlib.Path.rglob', return_value=[]), \+ patch('pathlib.Path.iterdir', return_value=[Path('/proc/789')]), \+ patch('review_kernel_env_parity.owned_kernel', return_value=None), \+ patch('review_kernel_env_parity.signal_owned') as sent, \+ patch('review_kernel_env_parity.live_identities', return_value=set()):+ reap_leftovers(Path('/fixture'), Path('/fixture/binary'), Path('/fixture/d.sock'),+ None, {789: 'proc:456'}, 123, '/fixture', {})+ sent.assert_not_called()+++if __name__ == '__main__':+ unittest.main()