Skip to content

A self-improving RLM agent for coding workflows and long-running autonomous tasks.

Rust

daemon: wait for a private default model's authorization at create; never fall back silently (#3628)

Sebastian Müller61b89bb9809b
diff --git a/crates/pa-core/src/models/mod.rs b/crates/pa-core/src/models/mod.rs
index 8ac717330a..4213d0d0c5 100644
--- a/crates/pa-core/src/models/mod.rs
+++ b/crates/pa-core/src/models/mod.rs
@@ -44,9 +44,10 @@ pub use prime_inference::{
pub use resolver::{
build_fallback_model, failover_candidates, find_exact_model_reference_match,
find_initial_model, find_preferred_default_model, resolve_cli_model,
- resolve_model_scope_from_models, InitialModelOptions, ResolveCliModelResult, ScopedModel,
- PRIME_INFERENCE_DEFAULT_MODEL_ID,
+ resolve_model_scope_from_models, scope_patterns_select_reference, InitialModelOptions,
+ ResolveCliModelResult, ScopedModel, PRIME_INFERENCE_DEFAULT_MODEL_ID,
};
pub use session_restore::{
- find_session_model_with_readiness_wait, SESSION_MODEL_RESTORE_READINESS_TIMEOUT_MS,
+ find_session_model_with_readiness_wait, resolve_model_scope_from_models_with_readiness,
+ SESSION_MODEL_RESTORE_READINESS_TIMEOUT_MS,
};
diff --git a/crates/pa-core/src/models/registry/tests.rs b/crates/pa-core/src/models/registry/tests.rs
index 888f719850..c32f2d8e4e 100644
--- a/crates/pa-core/src/models/registry/tests.rs
+++ b/crates/pa-core/src/models/registry/tests.rs
@@ -411,3 +411,46 @@ fn without_a_stored_xai_subscription_the_models_stay_on_completions() {
assert!(grok.thinking_level_map.is_none());
assert!(grok.compat.is_none());
}
+
+#[tokio::test]
+async fn scope_readiness_timeout_keeps_models_available_before_refresh() {
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let url = format!("http://{}", listener.local_addr().unwrap());
+ let auth = auth_without_env(&serde_json::json!({
+ "prime-inference": {
+ "type": "api_key", "key": "fixture-key",
+ "primeTeam": {"teamId": "team-1", "name": "Fixture"}
+ }
+ }));
+ let mut registry = ModelRegistry::in_memory(auth);
+ registry.catalog = Arc::new(pa_models::ModelCatalog::with_urls(None, None, &url, &url));
+ let existing = model("internal/existing", "prime-inference");
+ let missing = model("internal/missing", "prime-inference");
+ registry.models = vec![existing.clone(), missing];
+ registry.authorized_private_ids.insert(existing.id.clone());
+ registry.authorized_private_models = vec![existing.clone()];
+ registry.authorized_team_id = Some("team-1".to_string());
+ let patterns = vec![
+ "prime-inference/internal/existing".to_string(),
+ "prime-inference/internal/missing".to_string(),
+ ];
+ let resolved = super::super::session_restore::resolve_model_scope_from_models_with_readiness(
+ &mut registry,
+ &patterns,
+ Some(("prime-inference", "internal/missing")),
+ false,
+ 0,
+ )
+ .await;
+ assert!(
+ registry.authorized_private_ids.is_empty(),
+ "refresh started before timing out"
+ );
+ assert_eq!(
+ resolved
+ .into_iter()
+ .map(|entry| entry.model)
+ .collect::<Vec<_>>(),
+ vec![existing]
+ );
+}
diff --git a/crates/pa-core/src/models/resolver.rs b/crates/pa-core/src/models/resolver.rs
index 1ecdcba378..8f09603a92 100644
--- a/crates/pa-core/src/models/resolver.rs
+++ b/crates/pa-core/src/models/resolver.rs
@@ -287,6 +287,63 @@ fn glob_matches(pattern: &str, model: &Model) -> bool {
}
}
+/// Whether the scope would select this reference if it became available.
+/// Only the reference may join the authorized candidates; unrelated models
+/// from the full catalog must not change fuzzy selection.
+#[must_use]
+pub fn scope_patterns_select_reference(
+ patterns: &[String],
+ provider: &str,
+ model_id: &str,
+ available_models: &[Model],
+ all_models: &[Model],
+) -> bool {
+ let mut candidates = available_models.to_vec();
+ if !candidates
+ .iter()
+ .any(|model| model.provider == provider && model.id == model_id)
+ {
+ let Some(reference) = all_models
+ .iter()
+ .find(|model| model.provider == provider && model.id == model_id)
+ .cloned()
+ .or_else(|| build_fallback_model(provider, model_id, all_models))
+ else {
+ return false;
+ };
+ candidates.push(reference);
+ }
+ resolve_model_scope_from_models(patterns, &candidates)
+ .iter()
+ .any(|scoped| scoped.model.provider == provider && scoped.model.id == model_id)
+}
+
+fn pattern_matches<'a>(
+ pattern: &str,
+ available_models: &'a [Model],
+) -> (Vec<&'a Model>, Option<ThinkingLevel>, Option<String>) {
+ if pattern.contains('*') || pattern.contains('?') || pattern.contains('[') {
+ let (glob_pattern, thinking_level) = match pattern.rfind(':') {
+ Some(idx) if is_valid_thinking_level(&pattern[idx + 1..]) => {
+ (&pattern[..idx], parse_thinking_level(&pattern[idx + 1..]))
+ }
+ _ => (pattern, None),
+ };
+ let case_fold = glob_pattern.to_lowercase();
+ let matching = available_models
+ .iter()
+ .filter(|model| glob_matches(&case_fold, model) || glob_matches(glob_pattern, model))
+ .collect();
+ return (matching, thinking_level, None);
+ }
+ let parsed = parse_model_pattern(pattern, available_models, false);
+ (
+ parsed.model.into_iter().collect(),
+ parsed.thinking_level,
+ parsed.warning,
+ )
+}
+
/// Resolve model patterns to scoped models: exact/fuzzy for plain patterns,
/// glob expansion for wildcard patterns; `pattern:level` applies a level.
#[must_use]
@@ -296,47 +353,21 @@ pub fn resolve_model_scope_from_models(
) -> Vec<ScopedModel> {
let mut scoped: Vec<ScopedModel> = Vec::new();
for pattern in patterns {
- if pattern.contains('*') || pattern.contains('?') || pattern.contains('[') {
- let (glob_pattern, thinking_level) = match pattern.rfind(':') {
- Some(idx) if is_valid_thinking_level(&pattern[idx + 1..]) => {
- (&pattern[..idx], parse_thinking_level(&pattern[idx + 1..]))
- }
- _ => (pattern.as_str(), None),
- };
- let matching: Vec<&Model> = available_models
- .iter()
- .filter(|model| {
- let case_fold = glob_pattern.to_lowercase();
- glob_matches(&case_fold, model) || glob_matches(glob_pattern, model)
- })
- .collect();
- if matching.is_empty() {
- eprintln!("Warning: No models match pattern \"{pattern}\"");
- continue;
- }
- for model in matching {
- if !scoped.iter().any(|sm| models_equal(&sm.model, model)) {
- scoped.push(ScopedModel {
- model: model.clone(),
- thinking_level,
- });
- }
- }
- continue;
- }
- let parsed = parse_model_pattern(pattern, available_models, false);
- if let Some(warning) = &parsed.warning {
+ let (matching, thinking_level, warning) = pattern_matches(pattern, available_models);
+ if let Some(warning) = &warning {
eprintln!("Warning: {warning}");
}
- let Some(model) = parsed.model else {
+ if matching.is_empty() {
eprintln!("Warning: No models match pattern \"{pattern}\"");
continue;
- };
- if !scoped.iter().any(|sm| models_equal(&sm.model, model)) {
- scoped.push(ScopedModel {
- model: model.clone(),
- thinking_level: parsed.thinking_level,
- });
+ }
+ for model in matching {
+ if !scoped.iter().any(|sm| models_equal(&sm.model, model)) {
+ scoped.push(ScopedModel {
+ model: model.clone(),
+ thinking_level,
+ });
+ }
}
}
scoped
@@ -615,7 +646,8 @@ pub fn find_initial_model(options: &InitialModelOptions<'_>) -> Option<Model> {
/// The private-model predicate without a full `Model` value (TS
/// `isPrivatePrimeInferenceModel({ provider, id })`).
-fn is_private_prime_inference_reference(provider: &str, model_id: &str) -> bool {
+#[must_use]
+pub(super) fn is_private_prime_inference_reference(provider: &str, model_id: &str) -> bool {
provider == "prime-inference"
&& super::prime_inference::is_private_prime_inference_model_id(model_id)
}
@@ -645,6 +677,100 @@ mod tests {
]
}
+ #[test]
+ fn a_display_name_pattern_selects_a_cataloged_private_default() {
+ let all = private_prime_inference_models();
+ assert!(scope_patterns_select_reference(
+ &["GLM 5.2 Fast".to_string()],
+ "prime-inference",
+ "internal/glm-5.2-fast",
+ &all,
+ &all,
+ ));
+ }
+
+ #[test]
+ fn a_fuzzy_scope_uses_the_catalog_winner_not_a_singleton_default() {
+ let mut all = private_prime_inference_models();
+ all.push(model("prime-inference", "z-ai/glm-5.3", "GLM 5.3"));
+ let patterns = vec!["glm".to_string()];
+ let scoped = resolve_model_scope_from_models(&patterns, &all);
+ assert_eq!(
+ scoped
+ .iter()
+ .map(|entry| (entry.model.provider.as_str(), entry.model.id.as_str()))
+ .collect::<Vec<_>>(),
+ [("prime-inference", "z-ai/glm-5.3")]
+ );
+ assert!(!scope_patterns_select_reference(
+ &patterns,
+ "prime-inference",
+ "internal/glm-5.2-fast",
+ &all,
+ &all,
+ ));
+ assert!(scope_patterns_select_reference(
+ &patterns,
+ "prime-inference",
+ "z-ai/glm-5.3",
+ &all,
+ &all,
+ ));
+ }
+
+ #[test]
+ fn an_unlisted_private_reference_competes_with_the_full_catalog() {
+ let mut all = private_prime_inference_models();
+ all.push(model("prime-inference", "z-ai/glm-5.3", "GLM 5.3"));
+ for (pattern, selected) in [
+ ("glm", false),
+ ("prime-inference/internal/glm-5.9-turbo", true),
+ ("prime-inference/internal/*:high", true),
+ ] {
+ assert_eq!(
+ scope_patterns_select_reference(
+ &[pattern.to_string()],
+ "prime-inference",
+ "internal/glm-5.9-turbo",
+ &all,
+ &all,
+ ),
+ selected,
+ "pattern {pattern}"
+ );
+ }
+ }
+
+ #[test]
+ fn unavailable_competitors_do_not_hide_a_missing_scoped_default() {
+ let available = vec![model("prime-inference", "a-glm-5.2", "Public GLM 5.2")];
+ let mut all = private_prime_inference_models();
+ all.extend(available.iter().cloned());
+ all.push(model("custom", "zz-glm-5.2", "Unavailable GLM 5.2"));
+ let patterns = vec!["glm-5.2".to_string()];
+ assert_eq!(
+ resolve_model_scope_from_models(&patterns, &available)
+ .iter()
+ .map(|entry| entry.model.id.as_str())
+ .collect::<Vec<_>>(),
+ ["a-glm-5.2"]
+ );
+ assert!(scope_patterns_select_reference(
+ &patterns,
+ "prime-inference",
+ "internal/glm-5.2-fast",
+ &available,
+ &all,
+ ));
+ assert!(!scope_patterns_select_reference(
+ &patterns,
+ "prime-inference",
+ "internal/glm-5.2-fast",
+ &all,
+ &all,
+ ));
+ }
+
#[test]
fn failover_candidates_order_by_catalog_after_current() {
let mut catalog = catalog();
diff --git a/crates/pa-core/src/models/session_restore.rs b/crates/pa-core/src/models/session_restore.rs
index 8401cc2743..851d78f5a5 100644
--- a/crates/pa-core/src/models/session_restore.rs
+++ b/crates/pa-core/src/models/session_restore.rs
@@ -8,6 +8,10 @@ use std::time::Duration;
use pa_types::ai::Model;
use super::registry::ModelRegistry;
+use super::resolver::{
+ is_private_prime_inference_reference, resolve_model_scope_from_models,
+ scope_patterns_select_reference, ScopedModel,
+};
/// The bounded window a session-model restore waits for in-flight catalog/auth refreshes to settle
/// before the lookup may fail.
@@ -45,6 +49,45 @@ pub async fn find_session_model_with_readiness_wait(
find_restorable(registry, provider, model_id)
}
+pub async fn resolve_model_scope_from_models_with_readiness(
+ registry: &mut ModelRegistry,
+ patterns: &[String],
+ default: Option<(&str, &str)>,
+ is_continuing: bool,
+ readiness_timeout_ms: u64,
+) -> Vec<ScopedModel> {
+ let available: Vec<Model> = registry.get_available().into_iter().cloned().collect();
+ let scoped = resolve_model_scope_from_models(patterns, &available);
+ let default_missing = !is_continuing
+ && default.is_some_and(|(provider, model_id)| {
+ is_private_prime_inference_reference(provider, model_id)
+ && !scoped
+ .iter()
+ .any(|scoped| scoped.model.provider == provider && scoped.model.id == model_id)
+ && scope_patterns_select_reference(
+ patterns,
+ provider,
+ model_id,
+ &available,
+ registry.get_all(),
+ )
+ });
+ if !default_missing {
+ return scoped;
+ }
+ if tokio::time::timeout(
+ Duration::from_millis(readiness_timeout_ms),
+ registry.refresh_available_models(),
+ )
+ .await
+ .is_err()
+ {
+ return scoped;
+ }
+ let available: Vec<Model> = registry.get_available().into_iter().cloned().collect();
+ resolve_model_scope_from_models(patterns, &available)
+}
+
#[cfg(test)]
mod tests {
use super::*;
diff --git a/crates/pa-daemon/src/agent_engine/config.rs b/crates/pa-daemon/src/agent_engine/config.rs
index 7e7232bba2..ab19dbc0ed 100644
--- a/crates/pa-daemon/src/agent_engine/config.rs
+++ b/crates/pa-daemon/src/agent_engine/config.rs
@@ -95,9 +95,10 @@ pub(crate) struct CreateSessionResources {
/// The create command's `--models` scope inputs: the startup chain picks
/// the first scoped model (or the saved default when in scope) for a
/// fresh session; a continuing session keeps its own model.
-#[derive(Clone)]
+#[derive(Clone, Default)]
pub(super) struct StartupScope {
pub(super) scoped_models: Vec<pa_core::models::ScopedModel>,
+ pub(super) patterns: Vec<String>,
pub(super) is_continuing: bool,
}
diff --git a/crates/pa-daemon/src/agent_engine/model.rs b/crates/pa-daemon/src/agent_engine/model.rs
index c980cf0379..4d5cbfb4aa 100644
--- a/crates/pa-daemon/src/agent_engine/model.rs
+++ b/crates/pa-daemon/src/agent_engine/model.rs
@@ -3,7 +3,10 @@
//! session's live-model and thinking-level surfaces, and the request
//! API-key seam.
-use super::{AgentSessionEngine, EngineModelSelection, Model, RestoredSessionModel, SessionEngine};
+use super::{
+ AgentSessionEngine, EngineModelSelection, Model, RestoredSessionModel, SessionEngine,
+ StartupScope,
+};
impl AgentSessionEngine {
/// The startup chain: the saved settings default, then the featured
@@ -13,28 +16,84 @@ impl AgentSessionEngine {
let all: Vec<Model> = registry.get_all().to_vec();
let settings =
pa_core::settings::SettingsManager::create(self.cwd(), &self.config.agent_dir);
+ let default = settings
+ .get_default_provider()
+ .zip(settings.get_default_model())
+ .map(|(provider, model)| (provider.to_string(), model.to_string()));
// The create-time `--models` scope: a fresh session starts on the
// saved default when in scope, else the first scoped model.
- let (scoped_models, is_continuing) = match self
+ let scope = self
.startup_scope
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
.clone()
- {
- Some(scope) => (scope.scoped_models, scope.is_continuing),
- None => (Vec::new(), false),
- };
- pa_core::models::find_initial_model(&pa_core::models::InitialModelOptions {
+ .unwrap_or_default();
+ let resolved = pa_core::models::find_initial_model(&pa_core::models::InitialModelOptions {
cli_provider: None,
cli_model: None,
- scoped_models: &scoped_models,
- is_continuing,
- default_provider: settings.get_default_provider(),
- default_model_id: settings.get_default_model(),
+ scoped_models: &scope.scoped_models,
+ is_continuing: scope.is_continuing,
+ default_provider: default.as_ref().map(|(provider, _)| provider.as_str()),
+ default_model_id: default.as_ref().map(|(_, model)| model.as_str()),
all_models: &all,
available_models: &available,
})
- .or_else(|| all.first().cloned())
+ .or_else(|| all.first().cloned());
+ if let (Some(model), Some(default)) = (&resolved, &default) {
+ self.record_startup_default_fallback(model, default, &scope, &available, &all);
+ }
+ resolved
+ }
+
+ fn record_startup_default_fallback(
+ &self,
+ model: &Model,
+ default: &(String, String),
+ scope: &StartupScope,
+ available_models: &[Model],
+ all_models: &[Model],
+ ) {
+ let (provider, model_id) = default;
+ if scope.is_continuing || (model.provider == *provider && model.id == *model_id) {
+ return;
+ }
+ let session_file = self
+ .session_file
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner)
+ .clone()
+ .unwrap_or_default();
+ let mut decision = self
+ .restored_model
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ if decision
+ .as_ref()
+ .is_some_and(|decision| decision.session_file == session_file)
+ {
+ return;
+ }
+ let wanted = scope.patterns.is_empty()
+ || pa_core::models::scope_patterns_select_reference(
+ &scope.patterns,
+ provider,
+ model_id,
+ available_models,
+ all_models,
+ );
+ if !wanted {
+ return;
+ }
+ let message = format!(
+ "Default model {provider}/{model_id} is not available. Using {}/{}",
+ model.provider, model.id
+ );
+ eprintln!("{message}");
+ *decision = Some(RestoredSessionModel {
+ session_file,
+ model: None,
+ fallback_message: Some(message),
+ });
}
/// The runtime-config reset at every session restore: the create's own
diff --git a/crates/pa-daemon/src/agent_engine/session_engine_impl.rs b/crates/pa-daemon/src/agent_engine/session_engine_impl.rs
index 53457b9dd6..be01ca6db5 100644
--- a/crates/pa-daemon/src/agent_engine/session_engine_impl.rs
+++ b/crates/pa-daemon/src/agent_engine/session_engine_impl.rs
@@ -303,7 +303,8 @@ impl SessionEngine for AgentSessionEngine {
.session_file
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner)
- .clone()?;
+ .clone()
+ .unwrap_or_default();
if decision.session_file != current {
return None;
}
@@ -549,10 +550,12 @@ impl SessionEngine for AgentSessionEngine {
fn configure_startup_scope(
&self,
scoped_models: Vec<pa_core::models::ScopedModel>,
+ patterns: Vec<String>,
is_continuing: bool,
) {
*self.startup_scope.lock().unwrap() = Some(StartupScope {
scoped_models,
+ patterns,
is_continuing,
});
// The scope changed the startup decisions: drop the stale level; the
diff --git a/crates/pa-daemon/src/agent_engine/tests/model_resolution.rs b/crates/pa-daemon/src/agent_engine/tests/model_resolution.rs
index e5ec48f49b..10feff04ac 100644
--- a/crates/pa-daemon/src/agent_engine/tests/model_resolution.rs
+++ b/crates/pa-daemon/src/agent_engine/tests/model_resolution.rs
@@ -1217,3 +1217,176 @@ fn a_model_switch_keeps_the_agent_slot_in_sync_with_the_reported_level() {
"the agent slot re-syncs to the restored level"
);
}
+
+async fn private_default_create_worker(
+ dir: &std::path::Path,
+ responses: Vec<Vec<u8>>,
+) -> std::sync::Arc<crate::worker::Worker> {
+ let agent_dir = dir.join("agent");
+ write_prime_auth(&agent_dir);
+ std::fs::write(
+ agent_dir.join("settings.json"),
+ json!({
+ "defaultProvider": "prime-inference",
+ "defaultModel": "internal/glm-5.3-fast",
+ "enabledModels": [
+ "prime-inference/z-ai/glm-5.3",
+ "prime-inference/internal/glm-5.3-fast",
+ ]
+ })
+ .to_string(),
+ )
+ .unwrap();
+ let server = MockCatalogServer::start(responses).await;
+ install_loopback_catalog(&agent_dir, &server);
+ std::sync::Arc::new(crate::worker::Worker::new(
+ crate::worker::WorkerConfig {
+ socket_path: dir.join("worker.sock"),
+ supervisor_socket_path: std::path::PathBuf::new(),
+ token: "model-race".to_string(),
+ worker_instance_id: String::new(),
+ active_session_id: "race-create".to_string(),
+ agent_dir,
+ recovery_journal_path: dir.join("recovery.jsonl"),
+ script: None,
+ telemetry_disabled: Some(true),
+ },
+ None,
+ ))
+}
+
+async fn create_state(worker: &crate::worker::Worker, dir: &std::path::Path) -> Value {
+ let created = worker
+ .dispatch(
+ "create",
+ &json!({ "sessionPath": dir.join("race-session.jsonl"), "cwd": dir }),
+ )
+ .await;
+ assert!(created.success, "create failed: {created:?}");
+ let state = worker
+ .dispatch(
+ "get_connection_state",
+ &json!({ "activeSessionId": "race-create" }),
+ )
+ .await;
+ state.data.expect("state data")
+}
+
+#[tokio::test]
+async fn a_fresh_scoped_create_waits_for_the_private_default() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let pi = pi_payload();
+ let layer_a = json!({ "schemaVersion": 1, "models": [] }).to_string();
+ let worker = private_default_create_worker(
+ dir.path(),
+ vec![
+ catalog_ok_json(&layer_a),
+ catalog_ok_json(&pi),
+ catalog_ok_json(&pi),
+ ],
+ )
+ .await;
+ let data = create_state(&worker, dir.path()).await;
+ assert_eq!(
+ data["model"]["provider"], "prime-inference",
+ "the session runs on the provider default: {data}"
+ );
+ assert_eq!(
+ data["model"]["id"], "internal/glm-5.3-fast",
+ "the private default the patterns scope in wins the startup pick: {data}"
+ );
+}
+
+#[tokio::test]
+async fn a_fresh_scoped_create_falls_back_with_a_recorded_message() {
+ for no_session in [false, true] {
+ let dir = tempfile::TempDir::new().unwrap();
+ let worker = private_default_create_worker(dir.path(), Vec::new()).await;
+ let mut payload = json!({ "cwd": dir.path() });
+ if no_session {
+ payload["noSession"] = json!(true);
+ } else {
+ payload["sessionPath"] = json!(dir.path().join("race-session.jsonl"));
+ }
+ let created = worker.dispatch("create", &payload).await;
+ assert!(created.success, "create failed: {created:?}");
+ let summary = created.data.expect("create summary");
+ let state = worker
+ .dispatch(
+ "get_connection_state",
+ &json!({ "activeSessionId": "race-create" }),
+ )
+ .await;
+ let data = state.data.expect("state data");
+ assert_eq!(
+ data["model"]["id"], "z-ai/glm-5.3",
+ "the fallback is the first scoped model: {data}"
+ );
+ assert_eq!(
+ summary["modelFallbackMessage"],
+ "Default model prime-inference/internal/glm-5.3-fast is not available. Using prime-inference/z-ai/glm-5.3",
+ "the fallback is on the record (noSession={no_session}): {summary}"
+ );
+ let attached = worker
+ .dispatch("attach", &json!({ "activeSessionId": "race-create" }))
+ .await;
+ assert!(attached.success, "attach failed: {attached:?}");
+ let snapshot = attached.data.expect("attach data");
+ assert_eq!(
+ snapshot["snapshot"]["summary"]["modelFallbackMessage"],
+ summary["modelFallbackMessage"],
+ "the attach summary delivers the warning to the TUI"
+ );
+ if no_session {
+ let path = dir.path().join("authorized-session.jsonl");
+ let mut target =
+ crate::session_store::SessionFile::create(dir.path().to_str().unwrap(), None, 0);
+ target.set_path(path.clone());
+ target.append_model_change("prime-inference", "z-ai/glm-5.3");
+ target.rewrite().unwrap();
+ let switched = worker
+ .dispatch(
+ "switch_session",
+ &json!({ "activeSessionId": "race-create", "sessionPath": path }),
+ )
+ .await;
+ assert!(switched.success, "switch failed: {switched:?}");
+ let attached = worker
+ .dispatch("attach", &json!({ "activeSessionId": "race-create" }))
+ .await;
+ assert!(attached.success, "attach failed: {attached:?}");
+ let snapshot = attached.data.expect("replacement attach data");
+ assert!(
+ snapshot["snapshot"]["summary"]["modelFallbackMessage"].is_null(),
+ "navigation must not replay the old in-memory warning: {snapshot}"
+ );
+ }
+ }
+}
+
+#[test]
+fn an_explicit_scope_with_no_matches_does_not_warn_about_an_excluded_default() {
+ let dir = tempfile::TempDir::new().unwrap();
+ let agent_dir = dir.path().join("agent");
+ write_custom_provider_models_json(&agent_dir, "http://127.0.0.1:9");
+ std::fs::write(
+ agent_dir.join("settings.json"),
+ json!({"defaultProvider": "anthropic", "defaultModel": "excluded-default"}).to_string(),
+ )
+ .unwrap();
+ let engine = restore_test_engine(dir.path(), None, None);
+ *engine.startup_scope.lock().unwrap() = Some(StartupScope {
+ scoped_models: Vec::new(),
+ patterns: vec!["battery/no-such-model".to_string()],
+ is_continuing: false,
+ });
+ let resolved = engine.resolve_registry_model().expect("available fallback");
+ assert_eq!(
+ (resolved.provider.as_str(), resolved.id.as_str()),
+ ("battery", "mock-1")
+ );
+ assert!(
+ engine.model_fallback_message().is_none(),
+ "explicitly excluded defaults do not imply an unavailable-model fallback"
+ );
+}
diff --git a/crates/pa-daemon/src/agent_engine/turn/boundary.rs b/crates/pa-daemon/src/agent_engine/turn/boundary.rs
index 5b57a98299..380347dea9 100644
--- a/crates/pa-daemon/src/agent_engine/turn/boundary.rs
+++ b/crates/pa-daemon/src/agent_engine/turn/boundary.rs
@@ -196,6 +196,13 @@ impl AgentSessionEngine {
}
match consumption.refinement {
Some(Ok(refinement)) => {
+ let outcome =
+ pa_core::session_engine::refine::create_refinement_outcome_message(&refinement);
+ if !emit(EngineEvent::CustomMessage(
+ crate::session_commands::custom_message_value(&outcome),
+ )) {
+ return BoundaryRun::Cancelled;
+ }
if refinement.applied_edits.iter().any(|edit| edit.applied) {
let notice = pa_core::session_engine::refine::create_refinement_notice_message(
&refinement,
@@ -230,3 +237,70 @@ impl AgentSessionEngine {
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::agent_engine::tests::{admit, faux_engine_with_settings};
+ use crate::agent_engine::FAUX_TEST_LOCK;
+ use pa_core::session_engine::turn_boundary::PendingRefine;
+ use serde_json::json;
+
+ #[test]
+ fn requested_refinement_emits_its_durable_outcome_before_completion() {
+ let _faux = FAUX_TEST_LOCK
+ .lock()
+ .unwrap_or_else(std::sync::PoisonError::into_inner);
+ let (mut engine, dir) = faux_engine_with_settings(
+ &json!({"responses": [
+ {"text": "seed reply"},
+ {"text": json!({
+ "summary": "No durable change justified",
+ "rationale": "Fixture only",
+ "expectedOutcome": "No change",
+ "edits": []
+ }).to_string()}
+ ]}),
+ 1,
+ );
+ engine.config.session_dir = Some(dir.path().join("sessions"));
+ admit(&engine, "seed turn".to_string(), &mut Vec::new());
+ {
+ let guard = engine.session.blocking_lock();
+ let session = guard.as_ref().expect("built session");
+ engine
+ .runtime
+ .block_on(session.turn_boundary.schedule_refine(PendingRefine {
+ instructions: Some("Verify the completed outcome".to_string()),
+ global: false,
+ }));
+ }
+ let mut events = Vec::new();
+ let boundary = engine.run_turn_boundary(&mut |event| {
+ events.push(event);
+ true
+ });
+ assert!(matches!(boundary, BoundaryRun::Proceed));
+ let outcomes: Vec<_> = events
+ .iter()
+ .enumerate()
+ .filter(|(_, event)| {
+ matches!(event, EngineEvent::CustomMessage(row) if row["customType"] == "refinement_outcome")
+ })
+ .map(|(index, _)| index)
+ .collect();
+ assert_eq!(
+ outcomes.len(),
+ 1,
+ "one durable outcome, including a no-op refinement"
+ );
+ let completed = events
+ .iter()
+ .position(|event| matches!(event, EngineEvent::RefineComplete { .. }))
+ .expect("refinement completed");
+ assert!(
+ outcomes[0] < completed,
+ "persist the outcome before announcing completion"
+ );
+ }
+}
diff --git a/crates/pa-daemon/src/engine.rs b/crates/pa-daemon/src/engine.rs
index fd94870eb8..00b6acab32 100644
--- a/crates/pa-daemon/src/engine.rs
+++ b/crates/pa-daemon/src/engine.rs
@@ -263,6 +263,7 @@ pub trait SessionEngine: Send + Sync {
fn configure_startup_scope(
&self,
_scoped_models: Vec<pa_core::models::ScopedModel>,
+ _patterns: Vec<String>,
_is_continuing: bool,
) {
}
diff --git a/crates/pa-daemon/src/worker/create.rs b/crates/pa-daemon/src/worker/create.rs
index c232d6e830..a314558c29 100644
--- a/crates/pa-daemon/src/worker/create.rs
+++ b/crates/pa-daemon/src/worker/create.rs
@@ -384,6 +384,11 @@ impl Worker {
);
}
};
+ // The worker owns the session file; the engine reads it for the
+ // system prompt's conversation-log path and the local harness dir.
+ if !store.path.as_os_str().is_empty() {
+ self.engine.set_session_file(store.path.clone());
+ }
// The `models` patterns (else settings `enabledModels`) resolve once into
// the scoped list, AFTER the store open (the saved-model restore's wait
@@ -394,21 +399,29 @@ impl Worker {
.filter_map(Value::as_str)
.map(str::to_string)
.collect::<Vec<String>>(),
- None => pa_core::settings::SettingsManager::create(&cwd, &self.config.agent_dir)
- .get_enabled_models()
- .unwrap_or_default(),
+ None => settings.get_enabled_models().unwrap_or_default(),
};
+ let is_continuing = opened_existing_session;
let scoped_models = if model_patterns.is_empty() {
Vec::new()
} else {
- let registry = crate::state_getters::worker_model_registry(&self.config.agent_dir);
- let available: Vec<pa_types::ai::Model> =
- registry.get_available().into_iter().cloned().collect();
- pa_core::models::resolve_model_scope_from_models(&model_patterns, &available)
+ let mut registry = crate::state_getters::worker_model_registry(&self.config.agent_dir);
+ pa_core::models::resolve_model_scope_from_models_with_readiness(
+ &mut registry,
+ &model_patterns,
+ settings
+ .get_default_provider()
+ .zip(settings.get_default_model()),
+ is_continuing,
+ pa_core::models::SESSION_MODEL_RESTORE_READINESS_TIMEOUT_MS,
+ )
+ .await
};
- let is_continuing = opened_existing_session;
- self.engine
- .configure_startup_scope(scoped_models.clone(), is_continuing);
+ self.engine.configure_startup_scope(
+ scoped_models.clone(),
+ model_patterns.clone(),
+ is_continuing,
+ );
// The fresh arms' deferred creation prefix runs here, against the
// registered scope; the continuing arm wrote its own prefix above, so
// the scope never changes a continuing file's pinned model and thinking.
@@ -476,11 +489,6 @@ impl Worker {
None => (VecDeque::new(), VecDeque::new()),
}
};
- // The worker owns the session file; the engine reads it for the
- // system prompt's conversation-log path and the local harness dir.
- if !store.path.as_os_str().is_empty() {
- self.engine.set_session_file(store.path.clone());
- }
// The session's settings-seeded switches: a restarted session re-seeds
// its auto-compaction flag from the persisted `compaction.enabled`.
let (service_tier, steering_mode, follow_up_mode, auto_compaction_enabled) = {
diff --git a/crates/pa-tui/src/session_ui.rs b/crates/pa-tui/src/session_ui.rs
index acca9a774f..d473f9a57c 100644
--- a/crates/pa-tui/src/session_ui.rs
+++ b/crates/pa-tui/src/session_ui.rs
@@ -195,6 +195,7 @@ pub(crate) struct SessionUi {
/// `None` until the first sample, a rebind restarts it.
speed_stats: Option<SpeedStats>,
service_tier: Option<String>,
+ pending_model_fallback_message: Option<String>,
client_settings: Option<std::sync::Arc<dyn crate::client_settings::ClientSettings>>,
/// The ban-risk warning's view-local dedup (TS
/// `anthropicSubscriptionWarningShown`): this VIEW's own
diff --git a/crates/pa-tui/src/session_ui/lifecycle.rs b/crates/pa-tui/src/session_ui/lifecycle.rs
index 8059c0751e..1033e764b6 100644
--- a/crates/pa-tui/src/session_ui/lifecycle.rs
+++ b/crates/pa-tui/src/session_ui/lifecycle.rs
@@ -82,6 +82,7 @@ impl SessionUi {
show_images: options.show_images,
fullscreen_mouse: options.fullscreen_mouse,
service_tier: None,
+ pending_model_fallback_message: None,
speed_display_enabled: false,
speed_stats: None,
client_settings: options.client_settings.clone(),
@@ -421,6 +422,7 @@ impl SessionUi {
self.daemon_closing_notice = None;
self.session_name.clone_from(&reconstructed.session_name);
self.service_tier.clone_from(&reconstructed.service_tier);
+ self.pending_model_fallback_message = reconstructed.model_fallback_message;
self.session_file = attach
.snapshot
.get("state")
@@ -594,6 +596,13 @@ impl SessionUi {
view.push_entry(entry);
}
}
+ if let Some(message) = self.pending_model_fallback_message.take() {
+ view.push_entry(ChatEntry::Status {
+ text: format!("\u{26a0} {message}"),
+ kind: crate::chat::StatusKind::Warning,
+ });
+ self.last_status_index = None;
+ }
// The rebuild re-registers the live tool cards (the resumed turn's streamed calls re-enter
// the pending map): a post-reconnect failure frame can still settle them.
for entry in &view.chat {
@@ -769,3 +778,108 @@ impl SessionUi {
resume_hint_from_stats(&stats.ok()?.ok()?)
}
}
+
+#[cfg(all(test, unix))]
+mod backfill_tests {
+ use super::*;
+ use serde_json::json;
+ use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
+
+ #[tokio::test]
+ async fn an_attach_summary_model_fallback_warns_at_the_session_open() {
+ tokio::time::timeout(Duration::from_secs(10), async {
+ let dir = tempfile::tempdir().unwrap();
+ let socket = dir.path().join("fallback.sock");
+ let listener = tokio::net::UnixListener::bind(&socket).unwrap();
+ let server = tokio::spawn(async move {
+ let (stream, _) = listener.accept().await.unwrap();
+ let (read, mut write) = stream.into_split();
+ write.write_all(b"{\"type\":\"daemon_hello\",\"protocol\":{\"name\":\"prime-agent.daemon\",\"version\":7},\"serverCapabilities\":[],\"clientId\":\"mock\"}\n").await.unwrap();
+ let mut lines = BufReader::new(read).lines();
+ while let Some(line) = lines.next_line().await.unwrap() {
+ let request: Value = serde_json::from_str(&line).unwrap();
+ let kind = request["command"]["type"].as_str().unwrap();
+ let data = match kind {
+ "attach" => json!({
+ "activeSessionId": "s1", "snapshot": {
+ "activeSessionId": "s1",
+ "summary": {
+ "id": "s1", "cwd": "/tmp",
+ "modelFallbackMessage":
+ "Default model prime-inference/internal/glm-5.3-fast is not available. Using prime-inference/z-ai/glm-5.3",
+ },
+ "state": {"sessionId": "s1", "cwd": "/tmp", "isStreaming": false},
+ "messages": [], "lastEventSequence": 0,
+ }, "replay": {"status": "complete", "toSequence": 0},
+ "lastEventSequence": 0,
+ }),
+ _ => json!({}),
+ };
+ let mut reply = serde_json::to_vec(&json!({
+ "type": "response", "id": request["id"], "command": kind,
+ "success": true, "data": data,
+ }))
+ .unwrap();
+ reply.push(b'\n');
+ write.write_all(&reply).await.unwrap();
+ }
+ });
+ let mut options =
+ crate::interactive::tests::options(crate::interactive::ModelSelection::default());
+ options.socket_path = socket.clone();
+ options.session = SessionSelection::Attach("s1".to_string());
+ let (client, _events) = DaemonClient::connect(&socket).await.unwrap();
+ let mut session = SessionUi::open(
+ client,
+ &options,
+ mpsc::unbounded_channel().0,
+ mpsc::unbounded_channel().0,
+ mpsc::unbounded_channel().0,
+ mpsc::unbounded_channel().0,
+ mpsc::unbounded_channel().0,
+ mpsc::unbounded_channel().0,
+ mpsc::unbounded_channel().0,
+ mpsc::unbounded_channel().0,
+ mpsc::unbounded_channel().0,
+ ActivityUpdates {
+ heartbeats: mpsc::unbounded_channel().0,
+ bash: mpsc::unbounded_channel().0,
+ factory: mpsc::unbounded_channel().0,
+ commands: mpsc::unbounded_channel().0,
+ },
+ mpsc::unbounded_channel().0,
+ )
+ .await
+ .unwrap();
+ let mut view = AgentView::new(crate::theme::Theme::builtin(
+ "prime",
+ crate::theme::ColorMode::TrueColor,
+ ));
+ session.rebuild_view(&mut view, &RebuildKind::Rebind);
+ let warnings: Vec<String> = view
+ .chat
+ .iter()
+ .filter_map(|entry| match entry {
+ ChatEntry::Status { text, kind } if *kind == crate::chat::StatusKind::Warning => {
+ Some(text.clone())
+ }
+ _ => None,
+ })
+ .collect();
+ assert_eq!(
+ warnings,
+ vec!["\u{26a0} Default model prime-inference/internal/glm-5.3-fast is not available. Using prime-inference/z-ai/glm-5.3".to_string()],
+ "the startup fallback warns once at the open"
+ );
+ session.rebuild_view(&mut view, &RebuildKind::Resync);
+ assert!(
+ view.chat
+ .iter()
+ .all(|entry| !matches!(entry, ChatEntry::Status { kind: crate::chat::StatusKind::Warning, .. })),
+ "a second rebuild adds no second warning"
+ );
+ drop(session);
+ server.abort();
+ }).await.expect("mock session open, warning rebuild complete within ten seconds");
+ }
+}
diff --git a/crates/pa-tui/src/snapshot.rs b/crates/pa-tui/src/snapshot.rs
index bc1dc16b0b..9124f2fafb 100644
--- a/crates/pa-tui/src/snapshot.rs
+++ b/crates/pa-tui/src/snapshot.rs
@@ -79,6 +79,7 @@ pub struct Reconstructed {
/// The session's effective service tier (`state.serviceTier`), the
/// `/fast` toggle's baseline.
pub service_tier: Option<String>,
+ pub model_fallback_message: Option<String>,
/// The tail's oldest row when older history exists (the page cursor).
pub history_before_entry_id: Option<String>,
pub(crate) backfill_seam: BackfillSeam,
@@ -382,6 +383,11 @@ pub fn reconstruct(attach: &AttachData) -> Reconstructed {
.and_then(|state| state.get("serviceTier"))
.and_then(Value::as_str)
.map(str::to_string);
+ let model_fallback_message = snapshot
+ .get("summary")
+ .and_then(|summary| summary.get("modelFallbackMessage"))
+ .and_then(Value::as_str)
+ .map(str::to_string);
let history_before_entry_id = snapshot
.get("historyBeforeEntryId")
.and_then(Value::as_str)
@@ -415,6 +421,7 @@ pub fn reconstruct(attach: &AttachData) -> Reconstructed {
cursor_present,
queued,
service_tier,
+ model_fallback_message,
last_user_prompt_ms,
history_before_entry_id,
backfill_seam,
diff --git a/scripts/review_goal_fixture_lifecycle.py b/scripts/review_goal_fixture_lifecycle.py
index b1716b592d..899b5a7809 100644
--- a/scripts/review_goal_fixture_lifecycle.py
+++ b/scripts/review_goal_fixture_lifecycle.py
@@ -101,7 +101,7 @@ class OwnedProcesses:
current, state = process_identity(pid)
if current == identity and state != 'Z':
alive.append(pid)
- except FileNotFoundError:
+ except (FileNotFoundError, ProcessLookupError):
pass
return alive
diff --git a/scripts/review_kernel_env_parity.py b/scripts/review_kernel_env_parity.py
index 2eae95a658..403e183662 100644
--- a/scripts/review_kernel_env_parity.py
+++ b/scripts/review_kernel_env_parity.py
@@ -161,7 +161,7 @@ def wait_gone(identities):
current, state = process_identity(pid)
if current == identity and state != 'Z':
alive.append(pid)
- except FileNotFoundError:
+ except (FileNotFoundError, ProcessLookupError):
pass
if not alive:
return
@@ -229,7 +229,7 @@ def live_identities(identities):
current, state = process_identity(pid)
if current == identity and state != 'Z':
alive.add((pid, identity))
- except FileNotFoundError:
+ except (FileNotFoundError, ProcessLookupError):
pass
return alive
diff --git a/scripts/review_minimum_reasoning_parity.py b/scripts/review_minimum_reasoning_parity.py
index d88bf09004..c25b26ad6b 100644
--- a/scripts/review_minimum_reasoning_parity.py
+++ b/scripts/review_minimum_reasoning_parity.py
@@ -6,7 +6,9 @@ cells through their offered REPL tool. Only auxiliary request thinking controls
are compared, recording TS summary thinking-off as the intended correction:
prompt wording, token budgets, and whole UI/frame parity are not
claimed. Branch summary uses an owned daemon and its real navigate_tree command.
-All providers, homes, sessions, and subprocesses belong to this fixture.
+Both binaries use the same raw daemon commands; the owned supervisor shuts down
+workers and kernels before temporary files are removed. All providers, homes,
+sessions, and subprocesses belong to this fixture.
"""
import argparse
import http.server
@@ -14,15 +16,15 @@ import json
import os
from pathlib import Path
import sys
-import socket
import subprocess
-import time
import tempfile
import threading
+import time
from review_goal_backoff_parity import TS_ARCHIVE_SHA256, sha256
-from review_restore_notice_parity import invoke, probe_from
-from review_draft_disconnect_parity import stop
+from review_restore_notice_parity import invoke, probe_from, texts
+from review_kernel_env_parity import KernelClient
+from review_goal_fixture_lifecycle import OwnedProcesses, TAG, finish
MARKER = 'MINIMUM_REASONING_RESULT='
@@ -96,59 +98,53 @@ class Handler(http.server.BaseHTTPRequestHandler):
self.wfile.write(wire.encode())
-def summarize_branch(binary, root, cwd, env, session_file, observation):
+def summarize_branch(client, active, session_file):
entries = [json.loads(line) for line in session_file.read_text().splitlines()]
target = next(row['id'] for row in entries
if row.get('type') == 'message' and row.get('message', {}).get('role') == 'assistant')
- path = root / 'daemon.sock'
- with (root / 'daemon.log').open('wb') as log:
- process = subprocess.Popen([str(binary), '--mode', 'daemon', '--daemon-socket', str(path)],
- cwd=cwd, env=env, stdout=log, stderr=log, start_new_session=True)
- connection = None
- try:
- deadline = time.monotonic() + 35
- while time.monotonic() < deadline:
- assert process.poll() is None, 'owned daemon exited before socket readiness'
- try:
- connection = socket.socket(socket.AF_UNIX)
- connection.settimeout(60)
- connection.connect(str(path))
- break
- except (FileNotFoundError, ConnectionRefusedError):
- connection.close()
- connection = None
- threading.Event().wait(0.05)
- assert connection is not None, 'owned daemon socket never became ready'
- with connection.makefile('rb') as reader:
- hello = json.loads(reader.readline())
- assert hello.get('type') == 'daemon_hello', hello
- observation['daemon_hello'] = hello
- def command(identifier, payload):
- connection.sendall((json.dumps({'type': 'command', 'id': identifier,
- 'protocol': hello['protocol'], 'command': payload}) + '\n').encode())
- deadline = time.monotonic() + 60
- while time.monotonic() < deadline:
- line = reader.readline()
- assert line, 'owned daemon closed before response'
- row = json.loads(line)
- observation.setdefault('daemon_wire', []).append(row)
- if row.get('type') == 'response' and row.get('id') == identifier:
- assert row.get('success') is True, row
- return row
- raise TimeoutError('no response for ' + identifier)
- created = command('create', {'type': 'create', 'sessionPath': str(session_file),
- 'config': {'cwd': str(cwd), 'sessionDir': str(session_file.parent)}})
- active = created['data'].get('id') or created['data'].get('sessionId')
- assert active, created
- moved = command('branch', {'type': 'navigate_tree', 'activeSessionId': active,
- 'targetId': target, 'summarize': True,
- 'customInstructions': 'Verify mandatory thinking'})
- assert moved.get('data', {}).get('cancelled') is not True, moved
- finally:
- if connection is not None:
- connection.close()
- stop(process)
- observation['daemon_log'] = (root / 'daemon.log').read_text(errors='replace')
+ moved = client.call('navigate_tree', timeout_seconds=60, activeSessionId=active,
+ targetId=target, summarize=True,
+ customInstructions='Verify mandatory thinking')
+ assert moved.get('cancelled') is not True, moved
+
+
+def wait_for_operation(server, scenario, sessions, timeout_seconds=90):
+ """Turn-idle can precede the deferred operation and its continuation."""
+ deadline = time.monotonic() + timeout_seconds
+ while True:
+ assert server.error is None, server.error
+ bodies = [row['body'] for row in server.requests]
+ probe_ready = any(line.startswith(MARKER)
+ for body in bodies for message in body.get('messages', [])
+ if message.get('role') == 'tool'
+ for text in texts(message.get('content')) for line in text.splitlines())
+ scheduled = ({'scheduled': True} if scenario == 'branch' else
+ probe_from(bodies, MARKER) if probe_ready else None)
+ entries = []
+ complete = True
+ for path in sessions.rglob('*.jsonl'):
+ try:
+ data = path.read_bytes()
+ except FileNotFoundError:
+ complete = False # Listed inode retired before the read.
+ break
+ # Both writers terminate persisted records with a newline. Do not
+ # decode an in-flight tail, which may even split a UTF-8 character.
+ # Malformed complete records and other I/O errors remain failures.
+ if data and not data.endswith(b'\n'):
+ complete = False
+ break
+ entries.extend(json.loads(line) for line in data.splitlines() if line.strip())
+ outcomes = [entry for entry in entries if
+ (scenario == 'compact' and entry.get('type') == 'compaction') or
+ (scenario == 'refine' and entry.get('customType') == 'refinement_outcome') or
+ (scenario == 'branch' and entry.get('type') == 'branch_summary')]
+ if scheduled is not None and complete and outcomes:
+ return scheduled, outcomes
+ if time.monotonic() >= deadline:
+ raise AssertionError('timed out waiting for current scheduled probe and durable '
+ + scenario + ' outcome')
+ threading.Event().wait(0.025)
def run_case(binary, label, scenario, root, observation):
@@ -167,6 +163,7 @@ def run_case(binary, label, scenario, root, observation):
PRIME_AGENT_SESSION_DIR=str(sessions), XDG_CONFIG_HOME=str(root / 'config'),
XDG_CACHE_HOME=str(root / 'cache'), XDG_DATA_HOME=str(root / 'data'),
PYTHONPATH=os.pathsep.join(paths))
+ env[TAG] = str(root)
if label == 'ts':
env['PI_PACKAGE_DIR'] = os.environ['PI_PACKAGE_DIR']
server = Server(scenario)
@@ -190,21 +187,34 @@ def run_case(binary, label, scenario, root, observation):
'prewarmPythonKernel': False, 'compaction': {'enabled': False, 'keepRecentTokens': 100,
'reserveTokens': 1024},
'autoRefine': {'enabled': False}}))
- command = [str(binary), '--mode', 'json', '--provider', 'fixture', '--model',
- 'mandatory-fixture', '--thinking', 'low', '--session-dir', str(sessions),
- 'Seed the fixture.', 'Schedule the requested auxiliary operation.']
+ socket_path = root / 'daemon.sock'
+ scope = OwnedProcesses(binary, root, socket_path)
+ process = client = None
+ primary_error = None
+ log = (root / 'daemon.log').open('wb')
try:
observation['version'] = invoke([str(binary), '--version'], cwd, env)
- observation['process'] = invoke(command, cwd, env)
+ command = [str(binary), '--mode', 'daemon', '--daemon-socket', str(socket_path)]
+ process = subprocess.Popen(command, cwd=cwd, env=env, stdout=log,
+ stderr=log, start_new_session=True)
+ scope.register(process, command)
+ client = KernelClient(socket_path, process)
+ observation['daemon_hello'] = client.hello
+ created = client.call('create', config={
+ 'cwd': str(cwd), 'agentDir': str(agent), 'sessionDir': str(sessions),
+ 'provider': 'fixture', 'model': 'mandatory-fixture', 'thinkingLevel': 'low',
+ 'telemetryDisabled': True, 'noExtensions': True, 'noContextFiles': True})
+ active = created.get('activeSessionId') or created.get('id')
+ assert active, created
+ for message in ('Seed the fixture.', 'Schedule the requested auxiliary operation.'):
+ client.call('prompt_and_wait', timeout_seconds=90,
+ activeSessionId=active, message=message)
assert server.error is None, server.error
- bodies = [row['body'] for row in server.requests]
if scenario == 'branch':
session_files = list(sessions.rglob('*.jsonl'))
assert len(session_files) == 1, session_files
- summarize_branch(binary, root, cwd, env, session_files[0], observation)
- scheduled = {'scheduled': True}
- else:
- scheduled = probe_from(bodies, MARKER)
+ summarize_branch(client, active, session_files[0])
+ scheduled, outcomes = wait_for_operation(server, scenario, sessions)
observation['scheduled'] = scheduled
assert scheduled.get('scheduled') is True, scheduled
auxiliary = [row['body'] for row in server.requests if row['auxiliary']]
@@ -213,21 +223,26 @@ def run_case(binary, label, scenario, root, observation):
'reasoning', 'chat_template_kwargs') if key in body} for body in auxiliary]
expected = {'enable_thinking': label == 'rust' or scenario == 'refine'}
assert all(control == expected for control in controls), {'expected': expected, 'actual': controls}
- # A scheduled cell alone is insufficient: check the persisted operation result.
- entries = [json.loads(line) for path in sessions.rglob('*.jsonl')
- for line in path.read_text().splitlines() if line.strip()]
- outcomes = [entry for entry in entries if
- (scenario == 'compact' and entry.get('type') == 'compaction') or
- (scenario == 'refine' and entry.get('customType') == 'refinement_outcome') or
- (scenario == 'branch' and entry.get('type') == 'branch_summary')]
- assert outcomes, 'no durable completed ' + scenario + ' outcome'
observation.update(controls=controls, outcome_count=len(outcomes), tool_name=server.tool_name)
return {'scheduled': scheduled['scheduled'], 'completed': bool(outcomes)}
+ except BaseException as error:
+ primary_error = error
+ observation['primary_error'] = str(error)
+ raise
finally:
observation['requests'] = server.requests
+ observation['daemon_wire'] = list(client.wire) if client else []
+ # CLI exit leaves the TS kernel alive. Owning the supervisor gives both
+ # binaries the same acknowledged shutdown before temporary files vanish.
+ finish(scope, client, process, observation)
+ log.close()
+ observation['daemon_log'] = (root / 'daemon.log').read_text(errors='replace')[-6000:]
server.shutdown()
server.server_close()
thread.join(timeout=2)
+ assert not thread.is_alive(), 'fixture provider did not stop'
+ if not observation['cleanup_verified'] and primary_error is None:
+ raise AssertionError('fixture cleanup failed: ' + observation['cleanup_error'])
def main():
diff --git a/scripts/review_private_default_frames_parity.py b/scripts/review_private_default_frames_parity.py
new file mode 100644
index 0000000000..6b54ed3182
--- /dev/null
+++ b/scripts/review_private_default_frames_parity.py
@@ -0,0 +1,386 @@
+#!/usr/bin/env python3
+"""Actual TS/Rust fresh-startup model and warning captures, without inference.
+
+Uses the shared fingerprinted authorization-cache format with synthetic key/team
+and disables all external networking in a hosted-only network namespace. This
+measures fresh process startup from controlled cache states, not live catalog
+fetch timing. The current scoped-selection policy is characterized, not approved.
+"""
+import argparse
+import difflib
+import fcntl
+import hashlib
+import hmac
+import html
+import json
+import os
+from pathlib import Path
+import pty
+import select
+import signal
+import struct
+import subprocess
+import sys
+import tempfile
+import termios
+import threading
+import time
+
+from review_draft_disconnect_parity import Screen, TS_ARCHIVE_SHA256, digest, stop
+from review_goal_fixture_lifecycle import OwnedProcesses, TAG, finish
+from review_kernel_env_parity import KernelClient
+
+PUBLIC = 'z-ai/glm-5.3'
+PRIVATE = 'internal/glm-5.3-fast'
+KEY = 'startup-fixture-key-not-a-real-credential'
+TEAM = 'startup-fixture-team'
+INPUT = 'STARTUP_CAPTURE_INPUT'
+WARNING = 'Default model prime-inference/' + PRIVATE + ' is not available.'
+DIMENSIONS = ((120, 40), (80, 28))
+LIMIT = 45
+
+
+def private_item():
+ return {'id': PRIVATE, 'display_name': 'Private startup B',
+ 'pricing': {'input_usd_per_mtok': 1, 'output_usd_per_mtok': 1},
+ 'specs': {'context_window': 128000, 'max_output_tokens': 8192,
+ 'supports_reasoning': True,
+ 'modalities': {'input': ['text'], 'output': ['text']}}}
+
+
+def cache_document(authorized):
+ fingerprint = hmac.new(KEY.encode(),
+ b'prime-agent:private-prime-authorization:v1\0' + TEAM.encode(), hashlib.sha256).hexdigest()
+ return {'fingerprint': fingerprint, 'refreshedAt': int(time.time() * 1000),
+ 'data': [private_item()] if authorized else []}
+
+
+def prepare(root, label, scenario):
+ for name in ('home', 'agent', 'sessions', 'work', 'tmp', 'xdg'):
+ (root / name).mkdir(parents=True)
+ agent = root / 'agent'
+ (agent / 'auth.json').write_text(json.dumps({'prime-inference': {
+ 'type': 'api_key', 'key': KEY, 'primeTeam': {'teamId': TEAM, 'name': 'Synthetic team'}}}))
+ (agent / 'auth.json').chmod(0o600)
+ (agent / 'prime-inference-private-models.json').write_text(
+ json.dumps(cache_document(scenario != 'unavailable')))
+ (agent / 'prime-inference-private-models.json').chmod(0o600)
+ scope = [PUBLIC] if scenario == 'excluded' else [PUBLIC, PRIVATE]
+ (agent / 'settings.json').write_text(json.dumps({
+ 'defaultProvider': 'prime-inference', 'defaultModel': PRIVATE,
+ 'enabledModels': ['prime-inference/' + value for value in scope],
+ 'prewarmPythonKernel': False, 'onboardingCompleted': True,
+ 'onboardingShown': True, 'telemetry': {'noticeShown': True},
+ 'autoRefine': {'enabled': False}}))
+ (agent / 'models.json').write_text(json.dumps({'providers': {'prime-inference': {
+ 'api': 'openai-completions', 'baseUrl': 'https://api.pinference.ai/api/v1',
+ 'models': [{'id': PUBLIC, 'name': 'Public startup A',
+ 'reasoning': True, 'input': ['text'],
+ 'contextWindow': 128000, 'maxTokens': 8192}]}}}))
+ env = {name: os.environ[name] for name in ('PATH', 'LANG', 'LC_ALL', 'TZ') if name in os.environ}
+ env.update(HOME=str(root / 'home'), TMPDIR=str(root / 'tmp'),
+ XDG_CONFIG_HOME=str(root / 'xdg'), XDG_CACHE_HOME=str(root / 'xdg'),
+ XDG_DATA_HOME=str(root / 'xdg'), TERM='xterm-256color', COLORTERM='truecolor',
+ 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'),
+ PI_OFFLINE='1', DO_NOT_TRACK='1')
+ env[TAG] = str(root)
+ if label == 'ts':
+ env['PI_PACKAGE_DIR'] = os.environ['PI_PACKAGE_DIR']
+ return env
+
+
+class Terminal:
+ def __init__(self, command, cwd, env):
+ self.master, slave = pty.openpty()
+ attrs = termios.tcgetattr(slave)
+ attrs[3] &= ~(termios.ECHO | termios.ICANON)
+ termios.tcsetattr(slave, termios.TCSANOW, attrs)
+ fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack('HHHH', 40, 120, 0, 0))
+ self.process = subprocess.Popen(command, cwd=cwd, env=env, stdin=slave,
+ stdout=slave, stderr=slave, start_new_session=True)
+ os.close(slave)
+ self.screen, self.raw = Screen(120, 40), bytearray()
+ self.resize_events = [{'raw_offset': 0, 'columns': 120, 'rows': 40}]
+
+ def pump(self):
+ if select.select([self.master], [], [], 0.05)[0]:
+ try:
+ data = os.read(self.master, 65536)
+ except OSError:
+ data = b''
+ self.raw.extend(data)
+ for reply in self.screen.feed(data):
+ os.write(self.master, reply)
+
+ def wait(self, description, predicate):
+ deadline = time.monotonic() + LIMIT
+ while time.monotonic() < deadline:
+ self.pump()
+ assert self.process.poll() is None, 'TUI exited before ' + description
+ if predicate():
+ return
+ raise AssertionError('TUI readiness timed out: ' + description)
+
+ def resize(self, columns, rows):
+ self.resize_events.append({'raw_offset': len(self.raw), 'columns': columns, 'rows': rows})
+ self.screen = Screen(columns, rows)
+ fcntl.ioctl(self.master, termios.TIOCSWINSZ, struct.pack('HHHH', rows, columns, 0, 0))
+ os.kill(self.process.pid, signal.SIGWINCH)
+
+ def close(self):
+ stop(self.process)
+ os.close(self.master)
+
+
+def write_frame(directory, name, terminal):
+ text = terminal.screen.text()
+ (directory / (name + '.txt')).write_text(text + '\n')
+ width, height = terminal.screen.width, terminal.screen.height
+ lines = ''.join('<tspan x="12" y="' + str(22 + row * 18) + '">' + html.escape(line)
+ + '</tspan>' for row, line in enumerate(text.splitlines()))
+ # A readable rendering of actual captured cells; raw ANSI retains original
+ # colors/attributes. This SVG is not an OS-terminal pixel screenshot.
+ (directory / (name + '.svg')).write_text(
+ f'<svg xmlns="http://www.w3.org/2000/svg" width="{width * 10 + 24}" height="{height * 18 + 24}">'
+ '<rect width="100%" height="100%" fill="#111"/><text fill="#eee" '
+ 'font-family="monospace" font-size="16" xml:space="preserve">' + lines + '</text></svg>')
+ return {'columns': width, 'rows': height, 'text': text,
+ 'raw_end_offset': len(terminal.raw),
+ 'warning_prefix_count': text.count('Default model prime-inference/'),
+ 'input_preserved': INPUT in text}
+
+
+def active_worker(agent, socket_path):
+ candidates = []
+ for path in (agent / 'daemon-workers').rglob('*.json'):
+ try:
+ value = json.loads(path.read_text())
+ if value.get('supervisorSocketPath') == str(socket_path):
+ candidates.append(value['rootActiveSessionId'])
+ except (FileNotFoundError, json.JSONDecodeError, KeyError):
+ pass
+ ids = set(candidates)
+ assert len(ids) <= 1, 'ambiguous fixture worker identity'
+ return next(iter(ids)) if ids else None
+
+
+def connection_model(state):
+ return state.get('model') or state.get('state', {}).get('model')
+
+
+def wait_for_created_session(terminal, client, active):
+ state = None
+
+ def created():
+ nonlocal state
+ try:
+ state = client.call('get_connection_state', activeSessionId=active)
+ return True
+ except AssertionError as error:
+ # A descriptor identifies the spawned worker, not a completed create.
+ # Only this explicit transitional response is pending readiness;
+ # transport errors and every other daemon refusal still fail.
+ response = error.args[0] if error.args else None
+ if isinstance(response, dict) and response.get('success') is False:
+ info = response.get('errorInfo') or {}
+ if (response.get('error') == 'Unknown active session: ' + active
+ # Pinned TS requireAvailableWorkerClient reports its
+ # lifecycle before accepting forwarded state requests.
+ or response.get('error') in ('Session worker is starting',
+ 'Session worker is recovering', 'Session worker is not connected')
+ or (info.get('code') == 'session_recovering'
+ and info.get('activeSessionId') == active)):
+ return False
+ raise
+
+ terminal.wait('fresh session create completed', created)
+ return state
+
+
+def validate_observation(label, scenario, observed):
+ permitted = [PUBLIC, PRIVATE] if scenario == 'authorized' else [PUBLIC]
+ assert observed['selected_model'] in permitted, 'selected an unavailable or excluded model'
+ available = observed['available_ids']
+ assert PUBLIC in available, 'public fixture model is not available'
+ assert (PRIVATE in available) == (scenario != 'unavailable'), 'authorization fixture was not adopted'
+ expected_warning = label == 'rust' and scenario == 'unavailable'
+ if expected_warning:
+ assert observed['fallback_message'] and WARNING in observed['fallback_message'], 'missing warning on attach'
+ assert 'Using prime-inference/' + observed['selected_model'] in observed['fallback_message'], 'warning names the wrong fallback'
+ else:
+ assert not observed['fallback_message'], 'unexpected warning on attach'
+ for size, frame in observed['frames'].items():
+ assert size == f"{frame['columns']}x{frame['rows']}", 'mismatched terminal dimensions'
+ assert frame['input_preserved'], 'input disappeared across redraw'
+ assert frame['selected_model_id_visible'], 'model state has not reached the visible startup frame'
+ if frame['warning_prefix_count']:
+ assert frame['warning_text_complete'], 'visible warning was clipped'
+ expected = int(expected_warning) if size == '120x40' else None
+ if expected is not None:
+ assert frame['warning_prefix_count'] == expected, 'wrong initial visible warning count'
+ else:
+ assert frame['warning_prefix_count'] <= int(expected_warning), 'duplicate or unexpected resized warning'
+
+
+def capture(binary, label, scenario, root, directory, observed):
+ env = prepare(root, label, scenario)
+ socket_path = root / 'd.sock'
+ scope = OwnedProcesses(binary, root, socket_path)
+ process = client = terminal = None
+ primary = None
+ log = (root / 'daemon.log').open('wb')
+ directory.mkdir(parents=True)
+ try:
+ command = [str(binary), '--mode', 'daemon', '--daemon-socket', str(socket_path)]
+ process = subprocess.Popen(command, cwd=root / 'work', env=env, stdout=log,
+ stderr=log, start_new_session=True)
+ scope.register(process, command)
+ client = KernelClient(socket_path, process)
+ observed['hello'] = client.hello
+ command = [str(binary), '--daemon-socket', str(socket_path)]
+ terminal = Terminal(command, root / 'work', env)
+ scope.register(terminal.process, command)
+ terminal.wait('fresh worker descriptor', lambda: active_worker(root / 'agent', socket_path))
+ active = active_worker(root / 'agent', socket_path)
+ state = wait_for_created_session(terminal, client, active)
+ attached = client.call('attach', activeSessionId=active)
+ observed.update(active_session_id=active, state=state, attach=attached)
+ model = connection_model(state)
+ assert isinstance(model, dict) and model.get('provider') == 'prime-inference', state
+ selected = model.get('id')
+ observed['selected_model'] = selected
+ summary = attached.get('snapshot', {}).get('summary', {})
+ observed['fallback_message'] = summary.get('modelFallbackMessage')
+ terminal.wait('visible startup frame', lambda: bool(terminal.screen.text().strip()))
+ os.write(terminal.master, INPUT.encode())
+ expected_warning = label == 'rust' and scenario == 'unavailable'
+ terminal.wait('editor, selected model and startup warning', lambda: INPUT in terminal.screen.text()
+ and selected in terminal.screen.text()
+ and (not expected_warning or 'Default model prime-inference/' in terminal.screen.text()))
+ observed['frames'] = {}
+ for columns, rows in DIMENSIONS:
+ if terminal.screen.width != columns:
+ terminal.resize(columns, rows)
+ os.write(terminal.master, b'_NARROW')
+ terminal.wait('resized editor and selected model', lambda:
+ INPUT + '_NARROW' in terminal.screen.text() and selected in terminal.screen.text())
+ frame = write_frame(directory, f'{columns}x{rows}', terminal)
+ message = observed['fallback_message']
+ frame['warning_text_complete'] = not message or ''.join(message.split()) in ''.join(frame['text'].split())
+ frame['selected_model_name_visible'] = bool(model.get('name')) and model['name'] in frame['text']
+ frame['selected_model_id_visible'] = selected in frame['text']
+ observed['frames'][f'{columns}x{rows}'] = frame
+ # Observe availability only after capturing natural startup. Refreshing
+ # metadata beforehand could itself trigger a redraw or clear a notice.
+ models = client.call('get_available_models', activeSessionId=active)
+ observed['available_ids'] = [row['id'] for row in models['models']
+ if row.get('provider') == 'prime-inference']
+ after_refresh = client.call('get_connection_state', activeSessionId=active)
+ refreshed_model = connection_model(after_refresh) or {}
+ assert (refreshed_model.get('provider'), refreshed_model.get('id')) == (
+ model['provider'], selected), 'catalog read retargeted the active model'
+ validate_observation(label, scenario, observed)
+ observed['warning_present_after_resize'] = observed['frames']['80x28']['warning_prefix_count'] == 1
+ observed['capture_verified'] = True
+ except BaseException as error:
+ primary = error
+ observed['error'] = str(error)
+ raise
+ finally:
+ if terminal:
+ (directory / 'terminal.ansi').write_bytes(terminal.raw)
+ observed['resize_events'] = terminal.resize_events
+ if 'frames' not in observed:
+ observed['last_frame'] = write_frame(directory, 'failure', terminal)
+ terminal.close()
+ observed['wire'] = list(client.wire) if client else []
+ finish(scope, client, process, observed)
+ log.close()
+ observed['daemon_log'] = (root / 'daemon.log').read_text(errors='replace')[-6000:]
+ if not observed['cleanup_verified'] and primary is None:
+ raise AssertionError('owned startup fixture cleanup failed')
+
+
+def run(args):
+ subprocess.run(['ip', 'link', 'set', 'lo', 'up'], check=True)
+ routes = subprocess.check_output(['ip', 'route', 'show', 'default'], text=True).strip()
+ routes_v6 = subprocess.check_output(['ip', '-6', 'route', 'show', 'default'], text=True).strip()
+ assert not routes and not routes_v6, 'capture namespace must have no external route'
+ result = {'validation_passed': False, 'runs': {}, 'network_default_route': routes,
+ 'network_ipv6_default_route': routes_v6,
+ 'policy_decision_pending': True,
+ 'scope': 'Actual fresh TUI startup against owned daemons, matched PTY dimensions, signed synthetic authorization-cache states; no inference or external networking.',
+ 'limits': 'Does not exercise live catalog fetch timing, OS terminal font/pixel fidelity, or full application parity. SVGs render captured cells; raw ANSI preserves original attributes.',
+ 'expected_difference': 'The isolated TS findInitialModel resolver chooses the first scoped model, but TS main.ts buildSessionOptions first prefers an authorized saved default. Record the real startup selection without approving policy. Rust adds the requested-default-unavailable attach warning.',
+ 'source': {key: os.environ.get(key) for key in ('GITHUB_RUN_ID', 'GITHUB_SHA')}}
+ try:
+ if os.environ.get('GITHUB_EVENT_PATH'):
+ event = json.loads(Path(os.environ['GITHUB_EVENT_PATH']).read_text())
+ result['source']['pull_request_head_sha'] = event.get('pull_request', {}).get('head', {}).get('sha')
+ assert digest(Path(os.environ['PA_TS_ARCHIVE'])) == TS_ARCHIVE_SHA256
+ binaries = {label: Path(os.environ['PA_' + label.upper() + '_BINARY']).resolve()
+ for label in ('ts', 'rust')}
+ result['binaries'] = {label: {'path': str(path), 'sha256': digest(path)}
+ for label, path in binaries.items()}
+ output = args.receipt.with_suffix('')
+ errors = []
+ result['comparisons'] = {}
+ with tempfile.TemporaryDirectory(prefix='pa-startup-') as temp:
+ for scenario in ('authorized', 'unavailable', 'excluded'):
+ for label, binary in binaries.items():
+ name = scenario + '-' + label
+ observed = result['runs'][name] = {}
+ try:
+ capture(binary, label, scenario, Path(temp) / name, output / name, observed)
+ except Exception as error:
+ errors.append({'case': name, 'error': str(error)})
+ pair = {label: result['runs'][scenario + '-' + label] for label in binaries}
+ result['comparisons'][scenario] = {label: {
+ 'selected_model': value.get('selected_model'),
+ 'fallback_message': value.get('fallback_message'),
+ 'warning_present_after_resize': value.get('warning_present_after_resize'),
+ 'capture_verified': value.get('capture_verified', False)} for label, value in pair.items()}
+ for size in ('120x40', '80x28'):
+ if not all(size in value.get('frames', {}) for value in pair.values()):
+ continue
+ left, right = (pair[label]['frames'][size]['text'] for label in ('ts', 'rust'))
+ (output / (scenario + '-' + size + '.diff')).write_text(''.join(
+ difflib.unified_diff(left.splitlines(True), right.splitlines(True),
+ fromfile='TS0.9.8', tofile='Rust')))
+ assert not errors, errors
+ result['validation_passed'] = True
+ except BaseException as error:
+ result['error'] = str(error)
+ raise
+ finally:
+ args.receipt.parent.mkdir(parents=True, exist_ok=True)
+ args.receipt.write_text(json.dumps(result, indent=2) + '\n')
+
+
+def main():
+ parser = argparse.ArgumentParser(description=__doc__)
+ parser.add_argument('--receipt', type=Path, required=True)
+ parser.add_argument('--isolated-network', action='store_true')
+ args = parser.parse_args()
+ args.receipt = args.receipt.resolve()
+ assert sys.platform == 'linux' and os.environ.get('GITHUB_ACTIONS') == 'true', 'hosted Linux CI only'
+ repo = Path(__file__).resolve().parent.parent
+ assert args.receipt != repo and repo not in args.receipt.parents, 'receipt must be outside repository'
+ if not args.isolated_network:
+ args.receipt.parent.mkdir(parents=True, exist_ok=True)
+ args.receipt.write_text(json.dumps({'validation_passed': False,
+ 'error': 'network namespace capture child has not completed'}) + '\n')
+ names = ('PATH', 'LANG', 'LC_ALL', 'TZ', 'PA_TS_ARCHIVE', 'PA_TS_BINARY',
+ 'PA_RUST_BINARY', 'PI_PACKAGE_DIR', 'GITHUB_ACTIONS', 'GITHUB_RUN_ID', 'GITHUB_SHA',
+ 'GITHUB_EVENT_PATH')
+ values = [name + '=' + os.environ[name] for name in names if name in os.environ]
+ return subprocess.run(['sudo', '-n', 'unshare', '--net', '/usr/bin/env', *values,
+ sys.executable, str(Path(__file__).resolve()), '--isolated-network',
+ '--receipt', str(args.receipt)], check=False).returncode
+ run(args)
+ return 0
+
+
+if __name__ == '__main__':
+ raise SystemExit(main())
diff --git a/scripts/test_review_kernel_env_parity.py b/scripts/test_review_kernel_env_parity.py
index 44300c1c0a..6f4d76184c 100644
--- a/scripts/test_review_kernel_env_parity.py
+++ b/scripts/test_review_kernel_env_parity.py
@@ -8,7 +8,7 @@ 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
+from review_kernel_env_parity import current_probe, CODE, MARKER, owned_kernel, finish_daemon, KernelClient, signal_owned, reap_leftovers, wait_gone, live_identities
def requests(content=None):
@@ -81,6 +81,18 @@ class ProbeTests(unittest.TestCase):
finish_daemon(client, process)
process.wait.assert_not_called()
+ def test_process_exiting_during_proc_read_is_gone(self):
+ with patch('review_kernel_env_parity.process_identity', side_effect=ProcessLookupError(3, 'No such process')):
+ wait_gone({(789, 'proc:456')})
+ self.assertEqual(live_identities({(789, 'proc:456')}), set())
+
+ def test_other_proc_read_errors_still_fail_cleanup(self):
+ with patch('review_kernel_env_parity.process_identity', side_effect=PermissionError('denied')):
+ with self.assertRaises(PermissionError):
+ wait_gone({(789, 'proc:456')})
+ with self.assertRaises(PermissionError):
+ live_identities({(789, 'proc:456')})
+
def test_cold_kernel_response_after_35_seconds_uses_request_budget(self):
client = KernelClient.__new__(KernelClient)
client.counter, client.wire = 0, []
diff --git a/scripts/test_review_minimum_reasoning_parity.py b/scripts/test_review_minimum_reasoning_parity.py
new file mode 100644
index 0000000000..697ba10e69
--- /dev/null
+++ b/scripts/test_review_minimum_reasoning_parity.py
@@ -0,0 +1,189 @@
+#!/usr/bin/env python3
+"""Keep actual behavior gates and graceful fixture cleanup inseparable."""
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import MagicMock, patch
+
+from review_goal_fixture_lifecycle import OwnedProcesses
+from review_minimum_reasoning_parity import MARKER, run_case, summarize_branch, wait_for_operation
+
+
+class CleanupTests(unittest.TestCase):
+ def exercise(self, root, *, cleanup_failure=False, controls=True, durable=True):
+ library = root / 'library'
+ for skill in ('compact', 'refine'):
+ path = library / 'skills' / skill / 'src' / skill / '__init__.py'
+ path.parent.mkdir(parents=True)
+ path.touch()
+ case = root / 'case'
+ events = []
+ server, process, client, scope, thread = (MagicMock() for _ in range(5))
+ process.returncode = 0
+ scope.targets = {}
+ scope.errors = []
+ scope.live.return_value = []
+ thread.is_alive.return_value = False
+ server.server_address = ('127.0.0.1', 1234)
+ server.error = None
+ server.requests = [
+ {'auxiliary': False, 'body': {'messages': [
+ {'role': 'tool', 'content': MARKER + '{"scheduled":true}'}]}},
+ {'auxiliary': True, 'body': {'enable_thinking': controls}},
+ ]
+ def spawn(*args, **kwargs):
+ (case / 'sessions' / 'fixture.jsonl').write_text(
+ json.dumps({'type': 'compaction'}) + '\n' if durable else '')
+ return process
+ def command(kind, **kwargs):
+ events.append(kind)
+ return {'id': 'active'} if kind == 'create' else {}
+ client.call.side_effect = command
+ client.close.side_effect = lambda: events.append('control_closed')
+ process.wait.side_effect = lambda **kwargs: events.append('supervisor_exit')
+ if cleanup_failure:
+ scope.wait_gone.side_effect = [AssertionError('owned process remained'), None]
+ else:
+ scope.wait_gone.side_effect = lambda timeout: events.append('owned_processes_exited')
+ observation = {}
+ with patch.dict('os.environ', {'PI_PACKAGE_DIR': str(library)}), \
+ patch('review_minimum_reasoning_parity.Server', return_value=server), \
+ patch('review_minimum_reasoning_parity.threading.Thread', return_value=thread), \
+ patch('review_minimum_reasoning_parity.invoke', return_value={'exit_code': 0}), \
+ patch('review_minimum_reasoning_parity.subprocess.Popen', side_effect=spawn), \
+ patch('review_minimum_reasoning_parity.KernelClient', return_value=client), \
+ patch('review_minimum_reasoning_parity.OwnedProcesses', return_value=scope):
+ result = run_case(Path('/fixture/binary'), 'rust', 'compact', case, observation)
+ return result, observation, events
+
+ def test_daemon_commands_and_owned_exit_precede_directory_removal(self):
+ with tempfile.TemporaryDirectory() as temp:
+ result, observation, events = self.exercise(Path(temp))
+ self.assertEqual(result, {'scheduled': True, 'completed': True})
+ self.assertTrue(observation['cleanup_verified'])
+ self.assertEqual(events, ['create', 'prompt_and_wait', 'prompt_and_wait',
+ 'shutdown', 'control_closed', 'supervisor_exit', 'owned_processes_exited',
+ 'control_closed'])
+
+ def test_fallback_reaping_cannot_turn_failed_graceful_cleanup_green(self):
+ with tempfile.TemporaryDirectory() as temp:
+ with self.assertRaisesRegex(AssertionError, 'fixture cleanup failed: owned process remained'):
+ self.exercise(Path(temp), cleanup_failure=True)
+
+ def test_cleanup_cannot_hide_incorrect_thinking_controls(self):
+ with tempfile.TemporaryDirectory() as temp:
+ with self.assertRaisesRegex(AssertionError, 'expected'):
+ self.exercise(Path(temp), controls=False)
+
+ def test_cleanup_cannot_hide_missing_durable_outcome(self):
+ with tempfile.TemporaryDirectory() as temp, \
+ patch('review_minimum_reasoning_parity.time.monotonic', side_effect=[0, 91]):
+ with self.assertRaisesRegex(AssertionError, 'timed out waiting.*durable compact outcome'):
+ self.exercise(Path(temp), durable=False)
+
+ def test_turn_idle_does_not_end_wait_before_continuation_probe(self):
+ with tempfile.TemporaryDirectory() as temp:
+ sessions = Path(temp)
+ (sessions / 'session.jsonl').write_text(json.dumps({'type': 'compaction'}) + '\n')
+ server = MagicMock(error=None, requests=[])
+ event = MagicMock()
+ event.wait.side_effect = lambda _timeout: server.requests.append({'body': {
+ 'messages': [{'role': 'tool', 'content': MARKER + '{"scheduled":true}'}]}})
+ with patch('review_minimum_reasoning_parity.threading.Event', return_value=event):
+ self.assertEqual(wait_for_operation(server, 'compact', sessions),
+ ({'scheduled': True}, [{'type': 'compaction'}]))
+ event.wait.assert_called_once_with(0.025)
+
+ def test_probe_does_not_end_wait_before_durable_operation_outcome(self):
+ with tempfile.TemporaryDirectory() as temp:
+ sessions = Path(temp)
+ server = MagicMock(error=None, requests=[{'body': {'messages': [
+ {'role': 'tool', 'content': MARKER + '{"scheduled":true}'}]}}])
+ event = MagicMock()
+ event.wait.side_effect = lambda _timeout: (sessions / 'session.jsonl').write_text(
+ json.dumps({'type': 'refinement_outcome', 'customType': 'refinement_outcome'}) + '\n')
+ with patch('review_minimum_reasoning_parity.threading.Event', return_value=event):
+ scheduled, outcomes = wait_for_operation(server, 'refine', sessions)
+ self.assertEqual(scheduled, {'scheduled': True})
+ self.assertEqual(len(outcomes), 1)
+ event.wait.assert_called_once_with(0.025)
+
+ def test_invalid_current_probe_is_not_retried_until_it_disappears(self):
+ with tempfile.TemporaryDirectory() as temp:
+ server = MagicMock(error=None, requests=[{'body': {'messages': [
+ {'role': 'tool', 'content': MARKER + 'invalid-json'}]}}])
+ with patch('review_minimum_reasoning_parity.threading.Event') as event:
+ with self.assertRaises(json.JSONDecodeError):
+ wait_for_operation(server, 'compact', Path(temp))
+ event.assert_not_called()
+
+ def test_torn_utf8_tail_waits_for_a_complete_session_record(self):
+ with tempfile.TemporaryDirectory() as temp:
+ sessions = Path(temp)
+ path = sessions / 'session.jsonl'
+ path.write_bytes(b'{"type":"compaction","note":"\xc3')
+ server = MagicMock(error=None, requests=[{'body': {'messages': [
+ {'role': 'tool', 'content': MARKER + '{"scheduled":true}'}]}}])
+ event = MagicMock()
+ event.wait.side_effect = lambda _timeout: path.write_text('{"type":"compaction"}\n')
+ with patch('review_minimum_reasoning_parity.threading.Event', return_value=event):
+ self.assertEqual(wait_for_operation(server, 'compact', sessions),
+ ({'scheduled': True}, [{'type': 'compaction'}]))
+ event.wait.assert_called_once_with(0.025)
+
+ def test_file_replaced_between_listing_and_read_is_pending(self):
+ with tempfile.TemporaryDirectory() as temp:
+ sessions = Path(temp)
+ (sessions / 'session.jsonl').write_text('{"type":"compaction"}\n')
+ server = MagicMock(error=None, requests=[{'body': {'messages': [
+ {'role': 'tool', 'content': MARKER + '{"scheduled":true}'}]}}])
+ event = MagicMock()
+ with patch('pathlib.Path.read_bytes', side_effect=[FileNotFoundError(), b'{"type":"compaction"}\n']), \
+ patch('review_minimum_reasoning_parity.threading.Event', return_value=event):
+ self.assertEqual(wait_for_operation(server, 'compact', sessions),
+ ({'scheduled': True}, [{'type': 'compaction'}]))
+ event.wait.assert_called_once_with(0.025)
+
+ def test_complete_malformed_record_and_permission_errors_are_failures(self):
+ with tempfile.TemporaryDirectory() as temp:
+ sessions = Path(temp)
+ path = sessions / 'session.jsonl'
+ path.write_text('invalid-json\n')
+ server = MagicMock(error=None, requests=[{'body': {'messages': [
+ {'role': 'tool', 'content': MARKER + '{"scheduled":true}'}]}}])
+ with patch('review_minimum_reasoning_parity.threading.Event') as event:
+ with self.assertRaises(json.JSONDecodeError):
+ wait_for_operation(server, 'compact', sessions)
+ with patch('pathlib.Path.read_bytes', side_effect=PermissionError()):
+ with self.assertRaises(PermissionError):
+ wait_for_operation(server, 'compact', sessions)
+ event.assert_not_called()
+
+ def test_branch_uses_live_session_and_real_assistant_target(self):
+ with tempfile.TemporaryDirectory() as temp:
+ path = Path(temp) / 'session.jsonl'
+ path.write_text(json.dumps({'type': 'message', 'id': 'assistant',
+ 'message': {'role': 'assistant'}}))
+ client = MagicMock()
+ client.call.return_value = {}
+ summarize_branch(client, 'active', path)
+ client.call.assert_called_once_with('navigate_tree', timeout_seconds=60,
+ activeSessionId='active', targetId='assistant', summarize=True,
+ customInstructions='Verify mandatory thinking')
+ client.call.return_value = {'cancelled': True}
+ with self.assertRaises(AssertionError):
+ summarize_branch(client, 'active', path)
+
+ def test_proc_exit_race_is_gone_but_permission_errors_still_fail(self):
+ scope = OwnedProcesses(Path('/fixture/binary'), Path('/fixture'), Path('/fixture/d.sock'))
+ scope.targets = {789: 'proc:123'}
+ with patch('review_goal_fixture_lifecycle.process_identity', side_effect=ProcessLookupError()):
+ self.assertEqual(scope.live(), [])
+ with patch('review_goal_fixture_lifecycle.process_identity', side_effect=PermissionError()):
+ with self.assertRaises(PermissionError):
+ scope.live()
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/scripts/test_review_private_default_frames_parity.py b/scripts/test_review_private_default_frames_parity.py
new file mode 100644
index 0000000000..4b6f182475
--- /dev/null
+++ b/scripts/test_review_private_default_frames_parity.py
@@ -0,0 +1,110 @@
+"""Guard actual-startup receipt acceptance without choosing model priority."""
+import tempfile
+from pathlib import Path
+import unittest
+from unittest.mock import Mock
+
+from review_private_default_frames_parity import (
+ PUBLIC, PRIVATE, WARNING, Screen, connection_model, wait_for_created_session,
+ validate_observation, write_frame,
+)
+
+
+def observation(label, scenario):
+ warn = label == 'rust' and scenario == 'unavailable'
+ return {'selected_model': PUBLIC,
+ 'available_ids': [PUBLIC] if scenario == 'unavailable' else [PUBLIC, PRIVATE],
+ 'fallback_message': WARNING + ' Using prime-inference/' + PUBLIC if warn else None,
+ 'frames': {f'{columns}x{rows}': {'columns': columns, 'rows': rows,
+ 'input_preserved': True, 'selected_model_id_visible': True,
+ 'warning_prefix_count': int(warn), 'warning_text_complete': True}
+ for columns, rows in ((120, 40), (80, 28))}}
+
+
+class CaptureGuards(unittest.TestCase):
+ def test_spawned_worker_waits_for_create_but_other_refusals_fail(self):
+ terminal = Mock()
+ def wait(_description, predicate):
+ self.assertFalse(predicate())
+ self.assertTrue(predicate())
+ terminal.wait.side_effect = wait
+ state = {'model': {'id': PUBLIC}}
+ client = Mock()
+ client.call.side_effect = [AssertionError({'success': False,
+ 'error': 'Unknown active session: fixture'}), state]
+ self.assertEqual(wait_for_created_session(terminal, client, 'fixture'), state)
+ self.assertEqual(client.call.call_count, 2)
+ client.call.side_effect = [AssertionError({'success': False,
+ 'errorInfo': {'code': 'session_recovering', 'activeSessionId': 'fixture'}}), state]
+ self.assertEqual(wait_for_created_session(terminal, client, 'fixture'), state)
+ for message in ('Session worker is starting', 'Session worker is recovering',
+ 'Session worker is not connected'):
+ client.call.side_effect = [AssertionError({'success': False, 'error': message}), state]
+ self.assertEqual(wait_for_created_session(terminal, client, 'fixture'), state)
+ terminal.wait.side_effect = lambda _description, predicate: predicate()
+ for message in ('Permission denied', 'Session worker is failed', 'Session worker is stopping',
+ 'Daemon client is not attached to this session'):
+ client.call.side_effect = AssertionError({'success': False, 'error': message})
+ with self.assertRaises(AssertionError):
+ wait_for_created_session(terminal, client, 'fixture')
+ client.call.side_effect = AssertionError({'success': False,
+ 'errorInfo': {'code': 'session_recovering', 'activeSessionId': 'other'}})
+ with self.assertRaises(AssertionError):
+ wait_for_created_session(terminal, client, 'fixture')
+
+ def test_both_connection_state_shapes_keep_the_same_model(self):
+ model = {'id': PUBLIC, 'provider': 'prime-inference'}
+ self.assertEqual(connection_model({'model': model}),
+ connection_model({'state': {'model': model}}))
+
+ def test_characterization_does_not_approve_either_priority_policy(self):
+ for label in ('ts', 'rust'):
+ for selected in (PUBLIC, PRIVATE):
+ value = observation(label, 'authorized')
+ value['selected_model'] = selected
+ validate_observation(label, 'authorized', value)
+
+ def test_unavailable_or_excluded_private_model_is_rejected(self):
+ for scenario in ('unavailable', 'excluded'):
+ value = observation('rust', scenario)
+ value['selected_model'] = PRIVATE
+ with self.assertRaisesRegex(AssertionError, 'unavailable or excluded'):
+ validate_observation('rust', scenario, value)
+
+ def test_mismatched_authorization_state_is_rejected(self):
+ for scenario in ('authorized', 'unavailable'):
+ value = observation('rust', scenario)
+ value['available_ids'] = [PUBLIC] if scenario == 'authorized' else [PUBLIC, PRIVATE]
+ with self.assertRaisesRegex(AssertionError, 'authorization fixture'):
+ validate_observation('rust', scenario, value)
+
+ def test_missing_duplicate_warning_or_lost_input_is_rejected(self):
+ for field, replacement in (('warning_prefix_count', 0), ('warning_prefix_count', 2),
+ ('input_preserved', False), ('selected_model_id_visible', False),
+ ('columns', 119), ('warning_text_complete', False)):
+ value = observation('rust', 'unavailable')
+ value['frames']['120x40'][field] = replacement
+ with self.assertRaises(AssertionError):
+ validate_observation('rust', 'unavailable', value)
+
+ def test_unexpected_warning_in_ts_or_excluded_case_is_rejected(self):
+ for label, scenario in (('ts', 'unavailable'), ('rust', 'excluded')):
+ value = observation(label, scenario)
+ value['fallback_message'] = WARNING
+ with self.assertRaisesRegex(AssertionError, 'unexpected warning'):
+ validate_observation(label, scenario, value)
+
+ def test_svg_escapes_real_cells_and_retains_matched_dimensions(self):
+ screen = Screen(120, 40)
+ screen.feed(b'<fixture>&')
+ terminal = type('CapturedTerminal', (), {'screen': screen, 'raw': b'<fixture>&'})()
+ with tempfile.TemporaryDirectory() as temp:
+ frame = write_frame(Path(temp), 'capture', terminal)
+ self.assertEqual((frame['columns'], frame['rows']), (120, 40))
+ svg = (Path(temp) / 'capture.svg').read_text()
+ self.assertIn('&lt;fixture&gt;&amp;', svg)
+ self.assertNotIn('<fixture>', svg)
+
+
+if __name__ == '__main__':
+ unittest.main()