Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Merge remote-tracking branch 'upstream/main' into worktree-api-timeout-retry-v2

TheArchitectit9e50cb6e200b
diff --cc rust/crates/runtime/src/config.rs
index b31c0168,806c3ed5..c853479b
--- a/rust/crates/runtime/src/config.rs
+++ b/rust/crates/runtime/src/config.rs
@@@ -116,7 -139,32 +160,33 @@@ pub struct RuntimeFeatureConfig
sandbox: SandboxConfig,
provider_fallbacks: ProviderFallbackConfig,
trusted_roots: Vec<String>,
+ api_timeout: ApiTimeoutConfig,
+ rules_import: RulesImportConfig,
+ }
+
+ /// Controls which external AI coding framework rules are imported into the system prompt.
+ #[derive(Debug, Clone, PartialEq, Eq, Default)]
+ pub enum RulesImportConfig {
+ /// Import from all supported frameworks when files are detected.
+ #[default]
+ Auto,
+ /// Do not import external framework rules; keep Claw instruction files only.
+ None,
+ /// Import only the named frameworks.
+ List(Vec<String>),
+ }
+
+ impl RulesImportConfig {
+ #[must_use]
+ pub fn should_import(&self, framework: &str) -> bool {
+ match self {
+ Self::Auto => true,
+ Self::None => false,
+ Self::List(frameworks) => frameworks
+ .iter()
+ .any(|candidate| candidate.eq_ignore_ascii_case(framework)),
+ }
+ }
}
/// Ordered chain of fallback model identifiers used when the primary
@@@ -417,31 -459,293 +481,294 @@@ impl ConfigLoader
loaded_entries.push(entry);
}
- let merged_value = JsonValue::Object(merged.clone());
+ let config = build_runtime_config(merged, loaded_entries, mcp)?;
+ Ok((config, all_warnings))
+ }
- let feature_config = RuntimeFeatureConfig {
- hooks: parse_optional_hooks_config(&merged_value)?,
- plugins: parse_optional_plugin_config(&merged_value)?,
- mcp: McpConfigCollection {
- servers: mcp_servers,
- },
- oauth: parse_optional_oauth_config(&merged_value, "merged settings.oauth")?,
- model: parse_optional_model(&merged_value),
- aliases: parse_optional_aliases(&merged_value)?,
- permission_mode: parse_optional_permission_mode(&merged_value)?,
- permission_rules: parse_optional_permission_rules(&merged_value)?,
- sandbox: parse_optional_sandbox_config(&merged_value)?,
- provider_fallbacks: parse_optional_provider_fallbacks(&merged_value)?,
- trusted_roots: parse_optional_trusted_roots(&merged_value)?,
- api_timeout: parse_optional_api_timeout_config(&merged_value)?,
- };
+ /// Inspect every discovered config path and return per-file status details.
+ /// Unlike [`Self::load`], this is best-effort: invalid files are reported in
+ /// `files[]` and skipped from the merged runtime view so JSON config callers can
+ /// show the whole discovery picture without collapsing every unloaded path to
+ /// `loaded:false`.
+ #[must_use]
+ pub fn inspect_collecting_warnings(&self) -> ConfigInspection {
+ let mut merged = BTreeMap::new();
+ let mut loaded_entries = Vec::new();
+ let mut mcp = McpConfigCollection::default();
+ let mut warnings = Vec::new();
+ let mut files = Vec::new();
+ let mut load_error = None;
+
+ for (index, entry) in self.discover().into_iter().enumerate() {
+ let precedence_rank = index + 1;
+ if let Err(error) = crate::config_validate::check_unsupported_format(&entry.path) {
+ let detail = error.to_string();
+ load_error.get_or_insert_with(|| detail.clone());
+ files.push(ConfigFileReport::load_error(
+ entry,
+ precedence_rank,
+ "unsupported_format",
+ detail,
+ ));
+ continue;
+ }
- let config = RuntimeConfig {
- merged,
- loaded_entries,
- feature_config,
+ let parsed = match read_optional_json_object(&entry.path) {
+ Ok(OptionalConfigFile::Loaded(parsed)) => parsed,
+ Ok(OptionalConfigFile::NotFound) => {
+ files.push(ConfigFileReport::not_found(entry, precedence_rank));
+ continue;
+ }
+ Ok(OptionalConfigFile::Skipped { reason, detail }) => {
+ files.push(ConfigFileReport::skipped(
+ entry,
+ precedence_rank,
+ reason,
+ detail,
+ ));
+ continue;
+ }
+ Err(error) => {
+ let reason = config_error_reason(&error).to_string();
+ let detail = error.to_string();
+ load_error.get_or_insert_with(|| detail.clone());
+ files.push(ConfigFileReport::load_error(
+ entry,
+ precedence_rank,
+ reason,
+ detail,
+ ));
+ continue;
+ }
+ };
+
+ let validation = crate::config_validate::validate_config_file(
+ &parsed.object,
+ &parsed.source,
+ &entry.path,
+ );
+ if !validation.is_ok() {
+ let detail = validation.errors[0].to_string();
+ load_error.get_or_insert_with(|| detail.clone());
+ files.push(ConfigFileReport::load_error(
+ entry,
+ precedence_rank,
+ "validation_error",
+ detail,
+ ));
+ continue;
+ }
+ warnings.extend(
+ validation
+ .warnings
+ .iter()
+ .map(|warning| warning.to_string()),
+ );
+
+ if let Err(error) = validate_optional_hooks_config(&parsed.object, &entry.path) {
+ let detail = error.to_string();
+ load_error.get_or_insert_with(|| detail.clone());
+ files.push(ConfigFileReport::load_error(
+ entry,
+ precedence_rank,
+ "validation_error",
+ detail,
+ ));
+ continue;
+ }
+
+ if let Err(error) =
+ merge_mcp_servers(&mut mcp, entry.source, &parsed.object, &entry.path)
+ {
+ let detail = error.to_string();
+ load_error.get_or_insert_with(|| detail.clone());
+ files.push(ConfigFileReport::load_error(
+ entry,
+ precedence_rank,
+ "parse_error",
+ detail,
+ ));
+ continue;
+ }
+
+ let key_paths = collect_config_key_paths(&parsed.object);
+ deep_merge_objects(&mut merged, &parsed.object);
+ loaded_entries.push(entry.clone());
+ files.push(ConfigFileReport::loaded(entry, precedence_rank, key_paths));
+ }
+
+ annotate_config_file_precedence(&mut files);
+
+ let runtime_config = match build_runtime_config(merged, loaded_entries, mcp) {
+ Ok(config) => Some(config),
+ Err(error) => {
+ load_error.get_or_insert_with(|| error.to_string());
+ None
+ }
};
- Ok((config, all_warnings))
+
+ ConfigInspection {
+ files,
+ runtime_config,
+ warnings,
+ load_error,
+ }
+ }
+ }
+
+ impl ConfigFileReport {
+ fn loaded(entry: ConfigEntry, precedence_rank: usize, key_paths: Vec<String>) -> Self {
+ Self {
+ entry,
+ loaded: true,
+ status: ConfigFileStatus::Loaded,
+ reason: None,
+ detail: None,
+ precedence_rank,
+ wins_for_keys: Vec::new(),
+ shadowed_keys: Vec::new(),
+ key_paths,
+ }
+ }
+
+ fn not_found(entry: ConfigEntry, precedence_rank: usize) -> Self {
+ Self {
+ entry,
+ loaded: false,
+ status: ConfigFileStatus::NotFound,
+ reason: Some("not_found".to_string()),
+ detail: None,
+ precedence_rank,
+ wins_for_keys: Vec::new(),
+ shadowed_keys: Vec::new(),
+ key_paths: Vec::new(),
+ }
+ }
+
+ fn skipped(
+ entry: ConfigEntry,
+ precedence_rank: usize,
+ reason: String,
+ detail: Option<String>,
+ ) -> Self {
+ Self {
+ entry,
+ loaded: false,
+ status: ConfigFileStatus::Skipped,
+ reason: Some(reason),
+ detail,
+ precedence_rank,
+ wins_for_keys: Vec::new(),
+ shadowed_keys: Vec::new(),
+ key_paths: Vec::new(),
+ }
+ }
+
+ fn load_error(
+ entry: ConfigEntry,
+ precedence_rank: usize,
+ reason: impl Into<String>,
+ detail: String,
+ ) -> Self {
+ Self {
+ entry,
+ loaded: false,
+ status: ConfigFileStatus::LoadError,
+ reason: Some(reason.into()),
+ detail: Some(detail),
+ precedence_rank,
+ wins_for_keys: Vec::new(),
+ shadowed_keys: Vec::new(),
+ key_paths: Vec::new(),
+ }
+ }
+ }
+
+ fn annotate_config_file_precedence(files: &mut [ConfigFileReport]) {
+ let mut winning_file_by_key = BTreeMap::new();
+ for (index, file) in files.iter().enumerate() {
+ if !file.loaded {
+ continue;
+ }
+ for key in &file.key_paths {
+ winning_file_by_key.insert(key.clone(), index);
+ }
+ }
+
+ for (index, file) in files.iter_mut().enumerate() {
+ if !file.loaded {
+ continue;
+ }
+ let mut wins_for_keys = Vec::new();
+ let mut shadowed_keys = Vec::new();
+ for key in &file.key_paths {
+ if winning_file_by_key.get(key).copied() == Some(index) {
+ wins_for_keys.push(key.clone());
+ } else {
+ shadowed_keys.push(key.clone());
+ }
+ }
+ file.wins_for_keys = wins_for_keys;
+ file.shadowed_keys = shadowed_keys;
+ }
+ }
+
+ fn collect_config_key_paths(object: &BTreeMap<String, JsonValue>) -> Vec<String> {
+ let mut keys = Vec::new();
+ for (key, value) in object {
+ collect_config_key_paths_for_value(key, value, &mut keys);
+ }
+ keys
+ }
+
+ fn collect_config_key_paths_for_value(prefix: &str, value: &JsonValue, keys: &mut Vec<String>) {
+ match value {
+ JsonValue::Object(object) if !object.is_empty() => {
+ for (key, nested) in object {
+ collect_config_key_paths_for_value(&format!("{prefix}.{key}"), nested, keys);
+ }
+ }
+ _ => keys.push(prefix.to_string()),
+ }
+ }
+
+ fn build_runtime_config(
+ merged: BTreeMap<String, JsonValue>,
+ loaded_entries: Vec<ConfigEntry>,
+ mcp: McpConfigCollection,
+ ) -> Result<RuntimeConfig, ConfigError> {
+ let merged_value = JsonValue::Object(merged.clone());
+
+ let feature_config = RuntimeFeatureConfig {
+ hooks: parse_optional_hooks_config(&merged_value)?,
+ plugins: parse_optional_plugin_config(&merged_value)?,
+ mcp,
+ oauth: parse_optional_oauth_config(&merged_value, "merged settings.oauth")?,
+ model: parse_optional_model(&merged_value),
+ aliases: parse_optional_aliases(&merged_value)?,
+ permission_mode: parse_optional_permission_mode(&merged_value)?,
+ permission_rules: parse_optional_permission_rules(&merged_value)?,
+ sandbox: parse_optional_sandbox_config(&merged_value)?,
+ provider_fallbacks: parse_optional_provider_fallbacks(&merged_value)?,
+ trusted_roots: parse_optional_trusted_roots(&merged_value)?,
++ api_timeout: parse_optional_api_timeout_config(&merged_value)?,
+ rules_import: parse_optional_rules_import(&merged_value)?,
+ };
+
+ Ok(RuntimeConfig {
+ merged,
+ loaded_entries,
+ feature_config,
+ })
+ }
+
+ fn config_error_reason(error: &ConfigError) -> &'static str {
+ match error {
+ ConfigError::Io(io_error) if io_error.kind() == std::io::ErrorKind::PermissionDenied => {
+ "permission_denied"
+ }
+ ConfigError::Io(_) => "io_error",
+ ConfigError::Parse(_) => "parse_error",
}
}
diff --cc rust/crates/runtime/src/lib.rs
index f3997273,e11b91d8..d3e4da2e
--- a/rust/crates/runtime/src/lib.rs
+++ b/rust/crates/runtime/src/lib.rs
@@@ -65,12 -65,14 +65,14 @@@ pub use compact::
get_compact_continuation_message, should_compact, CompactionConfig, CompactionResult,
};
pub use config::{
- suppress_config_warnings_for_json_mode, ConfigEntry, ConfigError, ConfigFileReport,
- ConfigFileStatus, ConfigInspection, ConfigLoader, ConfigSource, McpConfigCollection,
- McpInvalidServerConfig, McpManagedProxyServerConfig, McpOAuthConfig, McpRemoteServerConfig,
- McpSdkServerConfig, McpServerConfig, McpStdioServerConfig, McpTransport,
+ suppress_config_warnings_for_json_mode, ApiTimeoutConfig, ConfigEntry, ConfigError,
- ConfigLoader, ConfigSource, McpConfigCollection, McpManagedProxyServerConfig, McpOAuthConfig,
++ ConfigFileReport, ConfigFileStatus, ConfigInspection, ConfigLoader, ConfigSource,
++ McpConfigCollection, McpInvalidServerConfig, McpManagedProxyServerConfig, McpOAuthConfig,
+ McpRemoteServerConfig, McpSdkServerConfig, McpServerConfig, McpStdioServerConfig, McpTransport,
McpWebSocketServerConfig, OAuthConfig, ProviderFallbackConfig, ResolvedPermissionMode,
- RuntimeConfig, RuntimeFeatureConfig, RuntimeHookConfig, RuntimePermissionRuleConfig,
- RuntimePluginConfig, ScopedMcpServerConfig, CLAW_SETTINGS_SCHEMA_NAME,
+ RulesImportConfig, RuntimeConfig, RuntimeFeatureConfig, RuntimeHookCommand, RuntimeHookConfig,
+ RuntimePermissionRuleConfig, RuntimePluginConfig, ScopedMcpServerConfig,
+ CLAW_SETTINGS_SCHEMA_NAME,
};
pub use config_validate::{
check_unsupported_format, format_diagnostics, validate_config_file, ConfigDiagnostic,