Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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<S
settings.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<S
cwd.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.rs
index 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.py
new file mode 100644
index 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.py
new file mode 100644
index 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()