1use std::collections::BTreeMap;
44use std::path::{Path, PathBuf};
45
46use anyhow::{Context as _, Result, bail};
47use serde::{Deserialize, Serialize};
48
49#[derive(Debug, thiserror::Error)]
52#[error("{stage}: {target}")]
53pub(crate) struct ConfigFailure {
54 pub(crate) stage: &'static str,
55 pub(crate) target: String,
56}
57
58impl ConfigFailure {
59 fn render(error: &teravars::Error, paths: &[PathBuf]) -> Self {
60 let stage = match error {
61 teravars::Error::Io(_) => "config-read",
62 teravars::Error::Toml(_) | teravars::Error::Extract(_) => "config-parse",
63 teravars::Error::Render(_) => "config-template",
64 teravars::Error::IncludeCycle { .. } | teravars::Error::IncludeConflict { .. } => {
65 "config-include"
66 }
67 _ => "config-render",
68 };
69 Self::layers(stage, paths)
70 }
71
72 fn layers(stage: &'static str, paths: &[PathBuf]) -> Self {
73 let targets: Vec<_> = paths
74 .iter()
75 .map(|path| {
76 path.ancestors()
79 .find(|p| p.join(REPO_MARKER).is_file())
80 .and_then(|root| path.strip_prefix(root).ok())
81 .unwrap_or(path)
82 .to_string_lossy()
83 .into_owned()
84 })
85 .collect();
86 Self {
87 stage,
88 target: serde_json::to_string(&targets).expect("config paths"),
89 }
90 }
91}
92
93#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
95#[serde(rename_all = "lowercase")]
96pub enum AgentKind {
97 Claude,
99 Opencode,
101 Antigravity,
105 Codex,
109 Omp,
115 Command,
117}
118
119impl AgentKind {
120 pub fn program(self) -> Option<&'static str> {
122 match self {
123 Self::Claude => Some("claude"),
124 Self::Opencode => Some("opencode"),
125 Self::Antigravity => Some("agy"),
126 Self::Codex => Some("codex"),
127 Self::Omp => Some("omp"),
128 Self::Command => None,
129 }
130 }
131
132 pub fn as_str(self) -> &'static str {
134 match self {
135 Self::Claude => "claude",
136 Self::Opencode => "opencode",
137 Self::Antigravity => "antigravity",
138 Self::Codex => "codex",
139 Self::Omp => "omp",
140 Self::Command => "command",
141 }
142 }
143
144 pub const ALL: [Self; 6] = [
152 Self::Claude,
153 Self::Opencode,
154 Self::Antigravity,
155 Self::Codex,
156 Self::Omp,
157 Self::Command,
158 ];
159}
160
161#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
163#[serde(rename_all = "lowercase")]
164pub enum Delivery {
165 Stdin,
167 Argv,
169 File,
171}
172
173#[derive(Debug, Clone, Deserialize, Serialize)]
175#[serde(deny_unknown_fields)]
176pub struct AgentSpec {
177 pub id: String,
179 pub kind: AgentKind,
181 #[serde(default)]
183 pub model: Option<String>,
184 #[serde(default)]
187 pub command: Vec<String>,
188 #[serde(default)]
190 pub extra_args: Vec<String>,
191 #[serde(default)]
193 pub env: BTreeMap<String, String>,
194 #[serde(default)]
196 pub prompt_delivery: Option<Delivery>,
197 #[serde(default, skip_serializing_if = "Option::is_none")]
200 pub max_turn_secs: Option<u64>,
201}
202
203impl AgentSpec {
204 pub fn turn_timeout(&self, budget: std::time::Duration) -> std::time::Duration {
206 self.max_turn_secs.map_or(budget, |secs| {
207 budget.min(std::time::Duration::from_secs(secs))
208 })
209 }
210
211 pub fn delivery(&self) -> Delivery {
217 self.prompt_delivery.unwrap_or(match self.kind {
218 AgentKind::Claude | AgentKind::Command => Delivery::Stdin,
219 AgentKind::Codex => Delivery::Stdin,
223 AgentKind::Omp => Delivery::Stdin,
227 AgentKind::Opencode | AgentKind::Antigravity => Delivery::File,
228 })
229 }
230
231 pub fn display(&self) -> String {
233 match &self.model {
234 Some(m) => format!("{} ({}:{m})", self.id, self.kind.as_str()),
235 None => format!("{} ({})", self.id, self.kind.as_str()),
236 }
237 }
238}
239
240#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
247#[serde(untagged)]
248pub enum AgentChoice {
249 One(String),
251 Chain(Vec<String>),
253}
254
255impl AgentChoice {
256 pub fn ids(&self) -> Vec<&str> {
258 let all: Vec<&str> = match self {
259 Self::One(id) => vec![id.as_str()],
260 Self::Chain(ids) => ids.iter().map(String::as_str).collect(),
261 };
262 all.into_iter()
263 .map(str::trim)
264 .filter(|id| !id.is_empty())
265 .collect()
266 }
267
268 pub fn primary(&self) -> Option<&str> {
270 self.ids().into_iter().next()
271 }
272}
273
274impl From<&str> for AgentChoice {
275 fn from(id: &str) -> Self {
276 Self::One(id.to_owned())
277 }
278}
279
280pub fn primary(choice: Option<&AgentChoice>) -> Option<&str> {
282 choice.and_then(AgentChoice::primary)
283}
284
285#[derive(Debug, Clone, Default, Deserialize, Serialize)]
288#[serde(deny_unknown_fields, default)]
289pub struct Roles {
290 pub implementers: Vec<String>,
292 pub judges: Vec<String>,
294 pub reviewers: Vec<String>,
296 pub fixer: Option<AgentChoice>,
305 pub chatter: Option<AgentChoice>,
319 pub dupes_judge: Option<AgentChoice>,
323 pub conductor: Option<AgentChoice>,
336 pub advisors: Vec<String>,
347 pub synthesizer: Option<AgentChoice>,
360 pub language_judge: Option<AgentChoice>,
369}
370
371#[derive(Debug, Clone, Deserialize, Serialize)]
373#[serde(deny_unknown_fields, default)]
374pub struct Graph {
375 #[serde(rename = "editing_network", skip_serializing)]
379 pub retired_editing_network: Option<serde::de::IgnoredAny>,
380 pub github_text_guard: bool,
382 pub github_language: String,
388 #[serde(alias = "candidates")]
420 pub implementers: usize,
421 #[serde(default)]
423 pub selected_implementer: Option<String>,
424 pub judges: usize,
426 pub deliberate_rounds: usize,
428 pub reviewers: usize,
436 pub review_rounds: usize,
438 pub gate_fix_rounds: usize,
444 pub max_parallel: usize,
446 pub language: String,
448 pub sessions: bool,
456 pub timeout_implement: u64,
458 pub timeout_judge: u64,
460 pub timeout_review: u64,
462 pub timeout_verify: Option<u64>,
471 pub timeout_fix: u64,
473 pub timeout_talk: u64,
481 pub timeout_resource_wait: u64,
490 pub retries: usize,
492 pub worktree_root: Option<PathBuf>,
494 pub land: bool,
507 pub land_rounds: usize,
509 pub rerun_flaky_checks: bool,
517 pub land_approval: bool,
528 pub hold_contested_merge: bool,
539 pub question_routing: bool,
542 pub file_followups: bool,
549 pub release_deputy_followups: bool,
557 pub answer_timeout: u64,
561 pub incomplete_review: IncompleteReviewPolicy,
564 pub e2e_every_round: bool,
582 pub advise: bool,
596 pub advisors: usize,
601 pub graft_runner_up: bool,
610}
611
612impl Default for Graph {
613 fn default() -> Self {
614 Self {
615 github_text_guard: true,
616 github_language: "en".into(),
617 implementers: 1,
618 selected_implementer: None,
619 retired_editing_network: None,
620 judges: 3,
621 deliberate_rounds: 1,
622 reviewers: 3,
623 review_rounds: 6,
624 gate_fix_rounds: 1,
625 max_parallel: 4,
626 language: "en".to_owned(),
627 sessions: true,
628 timeout_implement: 3600,
629 timeout_judge: 1200,
630 timeout_review: 1200,
631 timeout_verify: None,
632 timeout_fix: 1800,
633 timeout_talk: 3600,
634 timeout_resource_wait: 1800,
635 retries: 1,
636 worktree_root: None,
637 land: true,
638 land_rounds: 4,
639 rerun_flaky_checks: true,
640 land_approval: true,
641 hold_contested_merge: true,
642 question_routing: true,
643 file_followups: true,
644 release_deputy_followups: true,
645 answer_timeout: 86_400,
646 incomplete_review: IncompleteReviewPolicy::Block,
647 e2e_every_round: false,
648 advise: true,
649 advisors: 3,
650 graft_runner_up: true,
651 }
652 }
653}
654
655impl Graph {
656 pub fn verify_timeout(&self) -> u64 {
660 self.timeout_verify.unwrap_or(self.timeout_review)
661 }
662
663 pub fn language_gate(&self) -> bool {
666 self.github_text_guard && self.github_english()
667 }
668
669 pub fn github_english(&self) -> bool {
671 crate::lang::is_english(&self.github_language)
672 }
673}
674
675#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
682#[serde(rename_all = "lowercase")]
683pub enum IncompleteReviewPolicy {
684 Block,
688 Warn,
693}
694
695#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
697#[serde(rename_all = "lowercase")]
698pub enum LeakPolicy {
699 Warn,
701 Redact,
703 Fail,
705}
706
707#[derive(Debug, Clone, Deserialize, Serialize)]
714#[serde(deny_unknown_fields, default)]
715pub struct Blind {
716 pub commit_msg_hook: bool,
719 pub strip_lines: Vec<String>,
723 pub vendor_tokens: Vec<String>,
725 pub on_leak: LeakPolicy,
727 pub seed: Option<u64>,
730}
731
732impl Default for Blind {
733 fn default() -> Self {
734 Self {
735 commit_msg_hook: true,
736 strip_lines: [
737 "Co-Authored-By:",
738 "Signed-off-by:",
739 "Assisted-by:",
740 "Generated-by:",
741 "Generated with",
742 "\u{1f916}",
743 ]
744 .iter()
745 .map(|s| (*s).to_owned())
746 .collect(),
747 vendor_tokens: [
748 "claude",
749 "anthropic",
750 "codex",
751 "openai",
752 "chatgpt",
753 "gemini",
754 "grok",
755 "xai",
756 "copilot",
757 "opencode",
758 "qoder",
759 "cursor",
760 "\u{1f916}",
761 ]
762 .iter()
763 .map(|s| (*s).to_owned())
764 .collect(),
765 on_leak: LeakPolicy::Warn,
766 seed: None,
767 }
768 }
769}
770
771#[derive(Debug, Clone, Default, Deserialize, Serialize)]
773#[serde(deny_unknown_fields, default)]
774pub struct Verify {
775 pub e2e: Vec<String>,
778 pub gate: Vec<String>,
780 #[serde(default)]
791 pub pre_gate: Vec<String>,
792 pub shell: Option<Vec<String>>,
795}
796
797impl Verify {
798 pub fn cache_dir(&self) -> Option<PathBuf> {
804 self.e2e
805 .iter()
806 .chain(self.gate.iter())
807 .find_map(|cmd| crate::disk::extract_cargo_target_dir(cmd))
808 }
809
810 pub fn cargo_manifests(&self) -> Vec<PathBuf> {
813 let all: Vec<String> = self.e2e.iter().chain(self.gate.iter()).cloned().collect();
814 crate::cache::extract_manifest_paths(&all)
815 }
816}
817
818#[derive(Debug, Clone, Default, PartialEq, Deserialize, Serialize)]
820#[serde(deny_unknown_fields, default)]
821pub struct Worktree {
822 pub setup: Vec<SetupStep>,
825 pub pre_clean: Vec<PreCleanStep>,
827}
828
829#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
831#[serde(deny_unknown_fields)]
832pub struct PreCleanStep {
833 pub run: String,
835 pub timeout_secs: Option<u64>,
837}
838
839#[derive(Debug, Clone, Default, PartialEq, Deserialize, Serialize)]
841#[serde(deny_unknown_fields, default)]
842pub struct SetupStep {
843 pub copy: Option<String>,
846 pub optional: bool,
848 pub run: Option<String>,
850 pub timeout_secs: Option<u64>,
853}
854
855impl Worktree {
856 pub fn validate(&self) -> Result<()> {
858 for (i, step) in self.pre_clean.iter().enumerate() {
859 if step.run.trim().is_empty() || step.timeout_secs == Some(0) {
860 bail!(
861 "[worktree] pre_clean step {} requires a nonempty run and positive timeout",
862 i + 1
863 );
864 }
865 }
866 for (i, step) in self.setup.iter().enumerate() {
867 let n = i + 1;
868 match (&step.copy, &step.run) {
869 (Some(c), None) => {
870 if step.timeout_secs.is_some() {
871 bail!("[worktree] setup step {n}: `timeout_secs` applies to `run` only");
872 }
873 crate::worktree_setup::validate_copy(c)
874 .with_context(|| format!("[worktree] setup step {n}"))?;
875 }
876 (None, Some(r)) => {
877 if r.trim().is_empty() {
878 bail!("[worktree] setup step {n}: `run` is empty");
879 }
880 if step.optional {
881 bail!("[worktree] setup step {n}: `optional` applies to `copy` only");
882 }
883 }
884 _ => bail!("[worktree] setup step {n} must set exactly one of `copy` and `run`"),
885 }
886 }
887 Ok(())
888 }
889}
890
891#[derive(Debug, Clone, PartialEq, Deserialize, Serialize)]
901#[serde(deny_unknown_fields, default)]
902pub struct Disk {
903 pub min_free_bytes: u64,
912 pub auto_fold: bool,
918 pub fold_grace_secs: u64,
926 pub cache_limit_bytes: u64,
938 pub worktree_limit_bytes: u64,
940 pub worktree_reclaim_bytes: u64,
944 pub retained_attempt_limit: usize,
948}
949
950impl Default for Disk {
951 fn default() -> Self {
952 Self {
953 min_free_bytes: 8 * 1024 * 1024 * 1024,
954 auto_fold: true,
955 fold_grace_secs: 6 * 60 * 60,
956 cache_limit_bytes: 10 * 1024 * 1024 * 1024,
957 worktree_limit_bytes: 10 * 1024 * 1024 * 1024,
958 worktree_reclaim_bytes: 16 * 1024 * 1024 * 1024,
959 retained_attempt_limit: 8,
960 }
961 }
962}
963
964#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
966#[serde(rename_all = "lowercase")]
967pub enum MergeMode {
968 None,
971 Local,
974 Pr,
978}
979
980#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Deserialize, Serialize)]
994#[serde(rename_all = "lowercase")]
995pub enum MergeStyle {
996 #[default]
1001 Merge,
1002 Squash,
1008 Rebase,
1014}
1015
1016#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize, Serialize)]
1018#[serde(rename_all = "lowercase")]
1019pub enum MergeCi {
1020 #[default]
1022 Expected,
1023 None,
1025}
1026
1027impl MergeCi {
1028 pub fn expectation(self) -> crate::land::CiExpectation {
1030 match self {
1031 Self::Expected => crate::land::CiExpectation::Expected,
1032 Self::None => crate::land::CiExpectation::Absent,
1033 }
1034 }
1035}
1036
1037#[derive(Debug, Clone, Deserialize, Serialize)]
1039#[serde(deny_unknown_fields, default)]
1040pub struct Merge {
1041 pub mode: MergeMode,
1044 pub ci: MergeCi,
1046 pub base: Option<String>,
1048 pub style: MergeStyle,
1051 pub remote: String,
1053 pub release_bump: bool,
1066}
1067
1068impl Default for Merge {
1069 fn default() -> Self {
1070 Self {
1071 mode: MergeMode::None,
1072 ci: MergeCi::Expected,
1073 base: None,
1074 style: MergeStyle::default(),
1075 remote: "origin".to_owned(),
1076 release_bump: true,
1077 }
1078 }
1079}
1080
1081#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
1083#[serde(rename_all = "lowercase")]
1084pub enum UpdateMode {
1085 Off,
1087 Notify,
1090 Install,
1092}
1093
1094#[derive(Debug, Clone, Deserialize, Serialize)]
1096#[serde(deny_unknown_fields, default)]
1097pub struct Update {
1098 pub mode: UpdateMode,
1100 pub interval: Option<String>,
1102 pub auto_restart: bool,
1104}
1105
1106impl Default for Update {
1107 fn default() -> Self {
1108 Self {
1109 mode: UpdateMode::Notify,
1110 interval: None,
1111 auto_restart: false,
1112 }
1113 }
1114}
1115
1116#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Deserialize, Serialize)]
1118#[serde(rename_all = "lowercase")]
1119pub enum ReleaseMode {
1120 #[default]
1123 Actions,
1124 Local,
1129}
1130
1131#[derive(Debug, Clone, Deserialize, Serialize)]
1133#[serde(deny_unknown_fields, default)]
1134pub struct Release {
1135 pub mode: ReleaseMode,
1138 pub commands: Vec<String>,
1145 pub timeout_minutes: u64,
1147 pub version_files: Vec<VersionFile>,
1155}
1156
1157#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)]
1159#[serde(rename_all = "lowercase")]
1160pub enum VersionKind {
1161 Cargo,
1163 Json,
1165}
1166
1167#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
1169#[serde(deny_unknown_fields)]
1170pub struct VersionFile {
1171 pub path: String,
1173 pub kind: VersionKind,
1175}
1176
1177impl Default for Release {
1178 fn default() -> Self {
1179 Self {
1180 mode: ReleaseMode::Actions,
1181 commands: Vec::new(),
1182 timeout_minutes: 30,
1183 version_files: Vec::new(),
1184 }
1185 }
1186}
1187
1188impl Release {
1189 pub fn validate(&self) -> Result<()> {
1191 crate::release_manifest::validate(&self.version_files).context("[release] version_files")
1192 }
1193
1194 pub fn is_local(&self) -> bool {
1196 self.mode == ReleaseMode::Local
1197 }
1198}
1199
1200#[derive(Debug, Clone, Deserialize, Serialize)]
1202#[serde(try_from = "CoordinationFields")]
1203pub struct Coordination {
1204 pub contract_file: String,
1206 pub contract_token: String,
1208 pub lock_file: String,
1210}
1211
1212#[derive(Deserialize, Default)]
1213#[serde(deny_unknown_fields, default)]
1214struct CoordinationFields {
1215 contract_file: String,
1216 contract_token: String,
1217 lock_file: String,
1218}
1219
1220impl TryFrom<CoordinationFields> for Coordination {
1221 type Error = anyhow::Error;
1222
1223 fn try_from(fields: CoordinationFields) -> Result<Self> {
1224 for (key, name) in [
1225 ("coordination.contract_file", &fields.contract_file),
1226 ("coordination.lock_file", &fields.lock_file),
1227 ] {
1228 if name.trim().is_empty()
1229 || name != name.trim()
1230 || name == "."
1231 || name.contains("..")
1232 || name.contains(['/', '\\', ':', '\0'])
1233 {
1234 bail!(
1235 "{key} must be a plain file name inside the Git common directory (no separators or '..')"
1236 );
1237 }
1238 }
1239 let token = &fields.contract_token;
1240 if token.is_empty() || token.trim() != token || token.chars().any(char::is_control) {
1241 bail!(
1242 "coordination.contract_token must be a nonempty single-line token without surrounding whitespace"
1243 );
1244 }
1245 Ok(Self {
1246 contract_file: fields.contract_file,
1247 contract_token: fields.contract_token,
1248 lock_file: fields.lock_file,
1249 })
1250 }
1251}
1252
1253#[cfg(test)]
1254pub(crate) fn test_coordination() -> Option<Coordination> {
1255 Some(Coordination {
1256 contract_file: "updater.contract".into(),
1257 contract_token: "test-protocol-v1".into(),
1258 lock_file: "updater.lock".into(),
1259 })
1260}
1261
1262#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1264#[serde(deny_unknown_fields, default)]
1265pub struct Config {
1266 pub coordination: Option<Coordination>,
1268 pub agents: Vec<AgentSpec>,
1270 pub roles: Roles,
1272 pub graph: Graph,
1274 pub blind: Blind,
1276 pub verify: Verify,
1278 pub worktree: Worktree,
1280 pub disk: Disk,
1282 pub merge: Merge,
1284 pub update: Update,
1286 pub prompts: Prompts,
1288 pub notify: Notify,
1290 pub repos: Repos,
1293 pub talk: Talk,
1295 pub daemon: Daemon,
1297 pub release: Release,
1299 pub context_windows: BTreeMap<String, u64>,
1302}
1303
1304const BUILTIN_CONTEXT_WINDOWS: &[(&str, u64)] = &[
1314 ("claude-opus-4", 200_000),
1315 ("claude-sonnet-4", 200_000),
1316 ("claude-haiku-4", 200_000),
1317 ("claude-3", 200_000),
1318 ("opus", 200_000),
1319 ("sonnet", 200_000),
1320 ("haiku", 200_000),
1321 ("gpt-5", 400_000),
1322 ("gpt-4.1", 1_000_000),
1323 ("gpt-4o", 128_000),
1324 ("o3", 200_000),
1325 ("o4-mini", 200_000),
1326 ("gemini-2.5", 1_000_000),
1327 ("deepseek", 128_000),
1328];
1329
1330impl Config {
1331 pub fn context_window(&self, model: &str) -> Option<u64> {
1336 fn lookup<'a>(model: &str, entries: impl Iterator<Item = (&'a str, u64)>) -> Option<u64> {
1337 let mut best: Option<(usize, u64)> = None;
1338 for (key, window) in entries {
1339 if key == model {
1340 return Some(window);
1341 }
1342 if model.starts_with(key) && best.is_none_or(|(len, _)| key.len() > len) {
1343 best = Some((key.len(), window));
1344 }
1345 }
1346 best.map(|(_, w)| w)
1347 }
1348 lookup(
1349 model,
1350 self.context_windows.iter().map(|(k, w)| (k.as_str(), *w)),
1351 )
1352 .or_else(|| lookup(model, BUILTIN_CONTEXT_WINDOWS.iter().copied()))
1353 }
1354}
1355
1356#[derive(Debug, Clone, Deserialize, Serialize)]
1366#[serde(deny_unknown_fields, default)]
1367pub struct Daemon {
1368 pub max_concurrent_runs: usize,
1389 pub pause_for_interrupts: bool,
1405 pub max_deputies: usize,
1412 pub release_stall_minutes: u64,
1419}
1420
1421impl Default for Daemon {
1422 fn default() -> Self {
1423 Self {
1424 max_concurrent_runs: 1,
1425 pause_for_interrupts: false,
1426 max_deputies: 2,
1427 release_stall_minutes: 60,
1428 }
1429 }
1430}
1431
1432#[derive(Debug, Clone, Deserialize, Serialize)]
1444#[serde(deny_unknown_fields, default)]
1445pub struct Repos {
1446 pub roots: Vec<PathBuf>,
1450 pub auto_clone: bool,
1452 pub clone_command: Option<Vec<String>>,
1456 pub scan_ttl: u64,
1463 pub fetch_interval: u64,
1468}
1469
1470impl Default for Repos {
1471 fn default() -> Self {
1472 Self {
1473 roots: Vec::new(),
1474 auto_clone: false,
1475 clone_command: None,
1476 scan_ttl: 86_400,
1477 fetch_interval: 600,
1478 }
1479 }
1480}
1481
1482#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1498#[serde(deny_unknown_fields, default)]
1499pub struct Prompts {
1500 pub all: String,
1502 pub implement: String,
1504 pub judge: String,
1506 pub review: String,
1508 pub fix: String,
1510}
1511
1512impl Prompts {
1513 pub fn overlay(&self, node: &str) -> Option<String> {
1518 let specific = match node {
1519 "implement" => &self.implement,
1520 "judge" | "vote" | "deliberate" => &self.judge,
1521 "review" => &self.review,
1522 "fix" => &self.fix,
1523 _ => "",
1524 };
1525 let mut parts: Vec<&str> = Vec::new();
1526 for p in [self.all.trim(), specific.trim()] {
1527 if !p.is_empty() {
1528 parts.push(p);
1529 }
1530 }
1531 if parts.is_empty() {
1532 return None;
1533 }
1534 Some(parts.join("\n\n"))
1535 }
1536}
1537
1538#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1545#[serde(deny_unknown_fields, default)]
1546pub struct Notify {
1547 pub command: Vec<String>,
1550}
1551
1552#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1554#[serde(deny_unknown_fields, default)]
1555pub struct Talk {
1556 pub allow_write: bool,
1565 pub personas: Vec<PersonaSpec>,
1570 pub operator_name: Option<String>,
1574}
1575
1576pub const OPERATOR_NAME_MAX: usize = 64;
1578
1579impl Talk {
1580 pub fn operator_name(&self) -> Option<&str> {
1582 self.operator_name
1583 .as_deref()
1584 .map(str::trim)
1585 .filter(|n| !n.is_empty())
1586 }
1587}
1588
1589#[derive(Debug, Clone, Default, PartialEq, Eq, Deserialize, Serialize)]
1591#[serde(deny_unknown_fields)]
1592pub struct PersonaSpec {
1593 pub id: String,
1595 #[serde(default)]
1598 pub name: String,
1599 #[serde(default)]
1602 pub prompt: String,
1603 #[serde(default, skip_serializing_if = "Option::is_none")]
1607 pub icon: Option<String>,
1608}
1609
1610#[derive(Debug, Clone)]
1612pub struct ResolvedRoles {
1613 pub implementers: Vec<AgentSpec>,
1615 pub judges: Vec<AgentSpec>,
1617 pub reviewers: Vec<AgentSpec>,
1619 pub fixer: Option<Vec<AgentSpec>>,
1624 pub conductor: AgentSpec,
1626 pub implementer_roster: Vec<AgentSpec>,
1634 pub judge_roster: Vec<AgentSpec>,
1638 pub reviewer_roster: Vec<AgentSpec>,
1640}
1641
1642fn array_keys(table: &toml::value::Table, prefix: &str) -> Vec<String> {
1649 let mut out = Vec::new();
1650 for (k, v) in table {
1651 if prefix.is_empty() && k == "vars" {
1652 continue;
1653 }
1654 let path = if prefix.is_empty() {
1655 k.clone()
1656 } else {
1657 format!("{prefix}.{k}")
1658 };
1659 match v {
1660 toml::Value::Array(_) => out.push(path),
1661 toml::Value::Table(t) => out.extend(array_keys(t, &path)),
1662 _ => {}
1663 }
1664 }
1665 out
1666}
1667
1668#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1670enum ArrayMerge {
1671 Append,
1675 Replace,
1678}
1679
1680fn array_merge_policy(key: &str) -> ArrayMerge {
1719 match key {
1720 "verify.e2e" | "verify.gate" | "verify.pre_gate" | "repos.roots" => ArrayMerge::Append,
1721 _ => ArrayMerge::Replace,
1722 }
1723}
1724
1725impl Config {
1726 pub fn load(path: &Path) -> Result<Self> {
1729 Self::load_layers(&[path.to_path_buf()])
1730 }
1731
1732 fn render_ctx(paths: &[PathBuf]) -> teravars::Context {
1742 let mut ctx = teravars::system_context();
1743 let env: std::collections::BTreeMap<String, String> = std::env::vars().collect();
1744 ctx.insert("env", &env);
1745 if let Some(last) = paths.last()
1746 && let Some(dir) = last.parent()
1747 {
1748 let dir = std::fs::read_to_string(dir.join(REPO_MARKER))
1751 .map(|s| PathBuf::from(s.trim()))
1752 .unwrap_or_else(|_| dir.to_path_buf());
1753 ctx.insert("repo", &dir.to_string_lossy());
1754 ctx.insert(
1755 "repo_name",
1756 &dir.file_name().unwrap_or_default().to_string_lossy(),
1757 );
1758 }
1759 ctx
1760 }
1761
1762 pub fn load_layers(paths: &[PathBuf]) -> Result<Self> {
1770 let mut engine = teravars::Engine::default();
1771 let ctx = Self::render_ctx(paths);
1772 if paths.len() > 1 {
1773 Self::refuse_split_arrays(paths, &mut engine, &ctx).map_err(|error| {
1774 if error.downcast_ref::<ConfigFailure>().is_some() {
1775 error
1776 } else {
1777 let message = error.to_string();
1780 error
1781 .context(ConfigFailure::layers("config-merge", paths))
1782 .context(message)
1783 }
1784 })?;
1785 }
1786 let merged = teravars::load_merged(paths, &mut engine, &ctx)
1787 .map_err(|error| {
1788 let cause = ConfigFailure::render(&error, paths);
1789 anyhow::Error::new(error).context(cause)
1790 })
1791 .with_context(|| {
1792 format!(
1793 "rendering config via teravars: {}",
1794 paths
1795 .iter()
1796 .map(|p| p.display().to_string())
1797 .collect::<Vec<_>>()
1798 .join(", ")
1799 )
1800 })?;
1801 let mut table = merged.config;
1802 Self::normalize_renamed_keys(paths, &mut engine, &ctx, &mut table)?;
1803 table.remove("vars");
1806 let detect_agents = !table.contains_key("agents");
1810 let mut cfg: Self = toml::Value::Table(table)
1811 .try_into()
1812 .context("deserializing magi config")
1813 .context(ConfigFailure::layers("config-deserialize", paths))?;
1814 if !cfg.graph.question_routing {
1815 tracing::warn!(
1816 "[graph] question_routing is retired and ignored; task inquiries always use their chat"
1817 );
1818 }
1819 crate::persona::validate(&cfg.talk.personas)?;
1820 cfg.worktree.validate()?;
1821 cfg.release.validate()?;
1822 if let Some(name) = cfg.talk.operator_name() {
1823 if name.chars().count() > OPERATOR_NAME_MAX || name.chars().any(char::is_control) {
1824 bail!(
1825 "[talk] operator_name must be one line of at most {OPERATOR_NAME_MAX} characters"
1826 );
1827 }
1828 }
1829 if detect_agents {
1830 cfg.agents = Self::autodetected().agents;
1831 }
1832 Ok(cfg)
1833 }
1834
1835 fn normalize_renamed_keys(
1843 paths: &[PathBuf],
1844 engine: &mut teravars::Engine,
1845 ctx: &teravars::Context,
1846 table: &mut toml::map::Map<String, toml::Value>,
1847 ) -> Result<()> {
1848 let both = matches!(
1849 table.get("graph"),
1850 Some(toml::Value::Table(g)) if g.contains_key("candidates") && g.contains_key("implementers")
1851 );
1852 if !both {
1853 return Ok(());
1854 }
1855 let mut winner: Option<toml::Value> = None;
1856 for path in paths {
1857 let one = teravars::load_merged([path], engine, ctx)
1858 .map_err(|error| {
1859 let cause = ConfigFailure::render(&error, std::slice::from_ref(path));
1860 anyhow::Error::new(error).context(cause)
1861 })
1862 .with_context(|| format!("rendering {}", path.display()))?;
1863 let Some(toml::Value::Table(g)) = one.config.get("graph") else {
1864 continue;
1865 };
1866 if g.contains_key("candidates") && g.contains_key("implementers") {
1867 bail!(
1868 "`[graph]` sets both `implementers` and its deprecated alias \n `candidates` in {}; keep only `implementers`.",
1869 path.display()
1870 );
1871 }
1872 if let Some(v) = g.get("implementers").or_else(|| g.get("candidates")) {
1873 winner = Some(v.clone());
1874 }
1875 }
1876 if let Some(toml::Value::Table(g)) = table.get_mut("graph") {
1877 g.remove("candidates");
1878 if let Some(v) = winner {
1879 g.insert("implementers".to_owned(), v);
1880 }
1881 }
1882 Ok(())
1883 }
1884
1885 fn refuse_split_arrays(
1909 paths: &[PathBuf],
1910 engine: &mut teravars::Engine,
1911 ctx: &teravars::Context,
1912 ) -> Result<()> {
1913 let mut seen: std::collections::BTreeMap<String, PathBuf> = Default::default();
1914 for path in paths {
1915 let one = teravars::load_merged([path], engine, ctx)
1916 .map_err(|error| {
1917 let cause = ConfigFailure::render(&error, std::slice::from_ref(path));
1918 anyhow::Error::new(error).context(cause)
1919 })
1920 .with_context(|| format!("rendering {}", path.display()))?;
1921 for key in array_keys(&one.config, "") {
1922 if array_merge_policy(&key) == ArrayMerge::Append {
1923 continue;
1924 }
1925 if let Some(first) = seen.get(&key) {
1926 bail!(
1927 "`{key}` is an array declared in two config layers:\n \
1928 {}\n {}\nteravars appends arrays when it merges, so \
1929 magi would run the concatenation of both - which is \
1930 not what either file says. Declare `{key}` in exactly \
1931 one of them.",
1932 first.display(),
1933 path.display()
1934 );
1935 }
1936 seen.insert(key, path.clone());
1937 }
1938 }
1939 Ok(())
1940 }
1941
1942 pub fn array_provenance(paths: &[PathBuf], key: &str) -> Vec<(PathBuf, Vec<String>)> {
1964 let mut engine = teravars::Engine::default();
1965 let ctx = Self::render_ctx(paths);
1966 let mut out = Vec::new();
1967 for path in paths {
1968 let Ok(one) = teravars::load_merged([path], &mut engine, &ctx) else {
1969 continue;
1970 };
1971 let mut cur = &one.config;
1972 let mut found = None;
1973 let parts: Vec<&str> = key.split('.').collect();
1974 for (i, part) in parts.iter().enumerate() {
1975 match cur.get(*part) {
1976 Some(toml::Value::Array(a)) if i == parts.len() - 1 => {
1977 found = Some(a);
1978 break;
1979 }
1980 Some(toml::Value::Table(t)) => cur = t,
1981 _ => break,
1982 }
1983 }
1984 let Some(values) = found else { continue };
1985 let strings: Vec<String> = values
1986 .iter()
1987 .filter_map(|v| v.as_str().map(str::to_owned))
1988 .collect();
1989 if !strings.is_empty() {
1990 out.push((path.clone(), strings));
1991 }
1992 }
1993 out
1994 }
1995
1996 pub(crate) fn layer_tables(paths: &[PathBuf]) -> Vec<(PathBuf, Result<toml::Table>)> {
2002 let mut engine = teravars::Engine::default();
2003 let ctx = Self::render_ctx(paths);
2004 paths
2005 .iter()
2006 .map(|path| {
2007 let one = teravars::load_merged([path], &mut engine, &ctx)
2008 .map(|m| m.config)
2009 .with_context(|| format!("rendering {}", path.display()));
2010 (path.clone(), one)
2011 })
2012 .collect()
2013 }
2014
2015 pub fn describe_composed(
2025 paths: &[PathBuf],
2026 commands: &[String],
2027 key: &str,
2028 empty: &str,
2029 ) -> String {
2030 if commands.is_empty() {
2031 return empty.to_owned();
2032 }
2033 let joined = commands.join(" && ");
2034 let provenance = Self::array_provenance(paths, key);
2035 if provenance.len() <= 1 {
2036 return joined;
2037 }
2038 let mut out = joined;
2039 for (path, cmds) in &provenance {
2040 out.push_str(&format!("\n [{}] {}", path.display(), cmds.join(" && ")));
2041 }
2042 out
2043 }
2044
2045 pub fn discover(repo: &Path, explicit: Option<&Path>) -> Result<(Self, Vec<PathBuf>)> {
2052 #[cfg(test)]
2053 crate::web::request_cost::discovery();
2054 if let Some(p) = explicit {
2055 let paths = vec![p.to_path_buf()];
2056 return Ok((Self::load_layers(&paths)?, paths));
2057 }
2058 let paths = Self::layers_checked(repo)?;
2059 if paths.is_empty() {
2060 return Ok((Self::autodetected(), paths));
2061 }
2062 Ok((Self::load_layers(&paths)?, paths))
2063 }
2064
2065 pub async fn discover_fetched(
2068 repo: &Path,
2069 explicit: Option<&Path>,
2070 ) -> Result<(Self, Vec<PathBuf>)> {
2071 if explicit.is_none() && is_git_worktree(repo) {
2072 let (remote, cfg_base) = probe_remote_base(repo);
2076 let base = crate::git::merge_base_branch(repo, &remote, cfg_base.as_deref())
2077 .await
2078 .with_context(|| ConfigFailure {
2079 stage: "config-base",
2080 target: remote.clone(),
2081 })?;
2082 let out = crate::git::fetch(repo, &remote, &base)
2083 .await
2084 .with_context(|| format!("fetching {remote}/{base} to read magi.toml"))
2085 .with_context(|| ConfigFailure {
2086 stage: "config-fetch",
2087 target: format!("{remote}/{base}"),
2088 })?;
2089 if !out.ok() {
2090 return Err(anyhow::anyhow!(
2091 "cannot read magi.toml: `git fetch {remote} {base}` failed ({}); refusing to use the local checkout's copy, which may be stale",
2092 out.stderr.lines().next().unwrap_or("").trim()
2093 )).context(ConfigFailure { stage: "config-fetch", target: format!("{remote}/{base}") });
2094 }
2095 if cfg_base.is_none() {
2096 crate::git::ensure_remote_head(repo, &remote, &base).await;
2097 }
2098 }
2099 Self::discover(repo, explicit).map_err(|error| {
2100 if error.downcast_ref::<ConfigFailure>().is_some() {
2101 error
2102 } else {
2103 error.context(ConfigFailure {
2104 stage: "config-load",
2105 target: explicit.unwrap_or(repo).to_string_lossy().into_owned(),
2106 })
2107 }
2108 })
2109 }
2110
2111 fn layers_checked(repo: &Path) -> Result<Vec<PathBuf>> {
2113 if !is_git_worktree(repo) {
2114 return Ok(Self::layers(repo));
2115 }
2116 let mut paths: Vec<PathBuf> = Self::machine_layer()
2117 .into_iter()
2118 .filter(|p| p.is_file())
2119 .collect();
2120 paths.extend(Self::repo_layers(repo)?);
2121 Ok(paths)
2122 }
2123
2124 pub(crate) fn repo_layer_description(repo: &Path, path: &Path) -> String {
2126 let cached = path.ancestors().find(|p| p.join(REPO_MARKER).is_file());
2127 if let Some(root) = cached {
2128 let relative = path.strip_prefix(root).unwrap_or(path);
2129 let reference = resolve_remote_base(repo)
2130 .map(|(remote, base)| format!("{remote}/{base}"))
2131 .unwrap_or_else(|_| "remote base".to_owned());
2132 format!(
2133 "{} at {reference} (including its includes)",
2134 repo.join(relative).display()
2135 )
2136 } else {
2137 format!("{} (including its includes)", path.display())
2138 }
2139 }
2140
2141 pub(crate) fn repo_layers(repo: &Path) -> Result<Vec<PathBuf>> {
2144 if !is_git_worktree(repo) {
2145 return Ok([
2146 repo.join(".magi").join("config.toml"),
2147 repo.join("magi.toml"),
2148 ]
2149 .into_iter()
2150 .filter(|p| p.is_file())
2151 .collect());
2152 }
2153 remote_layers(repo)
2154 }
2155
2156 pub const CONFIG_DIR_ENV: &str = "MAGI_CONFIG_DIR";
2176
2177 pub fn layers(repo: &Path) -> Vec<PathBuf> {
2182 let mut paths = Vec::new();
2183 paths.extend(Self::machine_layer());
2184 paths.push(repo.join(".magi").join("config.toml"));
2185 paths.push(repo.join("magi.toml"));
2186 paths.retain(|p| p.is_file());
2187 paths
2188 }
2189
2190 #[cfg(test)]
2197 pub(crate) fn machine_layer() -> Option<PathBuf> {
2198 std::env::var(Self::CONFIG_DIR_ENV)
2199 .ok()
2200 .filter(|dir| !dir.trim().is_empty())
2201 .map(|dir| PathBuf::from(dir).join("magi").join("config.toml"))
2202 }
2203
2204 #[cfg(not(test))]
2206 pub(crate) fn machine_layer() -> Option<PathBuf> {
2207 match std::env::var(Self::CONFIG_DIR_ENV) {
2208 Ok(dir) if dir.trim().is_empty() => None,
2210 Ok(dir) => Some(PathBuf::from(dir).join("magi").join("config.toml")),
2211 Err(_) => dirs::config_dir().map(|dir| dir.join("magi").join("config.toml")),
2212 }
2213 }
2214
2215 pub fn autodetected() -> Self {
2217 let mut cfg = Self::default();
2218 for (kind, id, model) in [
2219 (AgentKind::Claude, "opus", Some("opus")),
2220 (AgentKind::Claude, "sonnet", Some("sonnet")),
2221 (AgentKind::Antigravity, "antigravity", None),
2222 (AgentKind::Opencode, "opencode", None),
2223 (AgentKind::Codex, "codex", None),
2224 (AgentKind::Omp, "omp", None),
2225 ] {
2226 if kind.program().is_some_and(which) && !cfg.agents.iter().any(|a| a.id == id) {
2227 cfg.agents.push(AgentSpec {
2228 id: id.to_owned(),
2229 kind,
2230 model: model.map(str::to_owned),
2231 command: Vec::new(),
2232 extra_args: Vec::new(),
2233 env: BTreeMap::new(),
2234 prompt_delivery: None,
2235 max_turn_secs: None,
2236 });
2237 }
2238 }
2239 cfg
2240 }
2241
2242 pub fn cache_dir(&self) -> Option<PathBuf> {
2245 self.verify.cache_dir()
2246 }
2247
2248 pub fn agent(&self, id: &str) -> Result<&AgentSpec> {
2250 self.agents
2251 .iter()
2252 .find(|a| a.id == id)
2253 .with_context(|| format!("no agent with id `{id}` in the roster"))
2254 }
2255
2256 fn rotate(&self, ids: &[String], count: usize, offset: usize) -> Result<Vec<AgentSpec>> {
2263 let mut out = Vec::with_capacity(count);
2264 for i in 0..count {
2265 let spec = if ids.is_empty() {
2266 self.agents[(i + offset) % self.agents.len()].clone()
2267 } else {
2268 self.agent(&ids[i % ids.len()])?.clone()
2269 };
2270 out.push(spec);
2271 }
2272 Ok(out)
2273 }
2274
2275 fn full_roster(&self, ids: &[String]) -> Result<Vec<AgentSpec>> {
2282 if ids.is_empty() {
2283 Ok(self.agents.clone())
2284 } else {
2285 ids.iter().map(|id| self.agent(id).cloned()).collect()
2286 }
2287 }
2288
2289 pub fn resolve_roles(&self) -> Result<ResolvedRoles> {
2296 if self.agents.is_empty() {
2297 bail!(
2298 "agent roster is empty: no agent CLI found on PATH and no \
2299 [[agents]] in the config. Run `magi init` to write a starter \
2300 magi.toml."
2301 );
2302 }
2303 let pinned = self
2304 .graph
2305 .selected_implementer
2306 .as_ref()
2307 .map(|id| self.agent(id).cloned())
2308 .transpose()?;
2309 Ok(ResolvedRoles {
2310 implementers: match &pinned {
2311 Some(agent) => vec![agent.clone()],
2312 None => self.rotate(&self.roles.implementers, self.graph.implementers, 0)?,
2313 },
2314 judges: self.rotate(&self.roles.judges, self.graph.judges, 1)?,
2315 reviewers: self.rotate(&self.roles.reviewers, self.graph.reviewers, 0)?,
2316 fixer: match self.roles.fixer.as_ref() {
2317 Some(choice) => Some(crate::agent::pick_chain(
2320 &self.agents,
2321 Some(choice),
2322 &|_| true,
2323 "fixer",
2324 )?),
2325 None => None,
2326 },
2327 conductor: match self.roles.conductor.as_ref().map(AgentChoice::ids) {
2332 Some(ids) if ids.len() == 1 => self.agent(ids[0])?.clone(),
2333 Some(ids) if !ids.is_empty() => ids
2336 .iter()
2337 .find_map(|id| self.agent(id).ok())
2338 .cloned()
2339 .with_context(|| {
2340 format!("[roles] conductor names no agent in the roster: {ids:?}")
2341 })?,
2342 _ => crate::agent::pick(&self.agents, None, &crate::agent::installed)
2347 .unwrap_or_else(|_| self.agents[0].clone()),
2348 },
2349 implementer_roster: match pinned {
2350 Some(agent) => vec![agent],
2351 None => self.full_roster(&self.roles.implementers)?,
2352 },
2353 judge_roster: self.full_roster(&self.roles.judges)?,
2354 reviewer_roster: self.full_roster(&self.roles.reviewers)?,
2355 })
2356 }
2357
2358 pub fn advisors(&self) -> Result<Vec<AgentSpec>> {
2380 if self.agents.is_empty() {
2381 bail!(
2382 "agent roster is empty: no agent CLI found on PATH and no \
2383 [[agents]] in the config. Run `magi init` to write a starter \
2384 magi.toml."
2385 );
2386 }
2387 if !self.roles.advisors.is_empty() {
2388 return self.rotate(&self.roles.advisors, self.graph.advisors, 0);
2389 }
2390 self.rotate(&self.roles.judges, self.graph.advisors, 1)
2391 }
2392
2393 pub fn advisor_roster(&self) -> Result<Vec<AgentSpec>> {
2397 if self.roles.advisors.is_empty() {
2398 self.full_roster(&self.roles.judges)
2399 } else {
2400 self.full_roster(&self.roles.advisors)
2401 }
2402 }
2403
2404 pub fn shell(&self) -> Vec<String> {
2406 if let Some(s) = &self.verify.shell {
2407 return s.clone();
2408 }
2409 if which("sh") {
2410 vec!["sh".to_owned(), "-c".to_owned()]
2411 } else {
2412 vec!["cmd".to_owned(), "/C".to_owned()]
2413 }
2414 }
2415
2416 pub fn starter_toml() -> String {
2418 let detected = Self::autodetected();
2419 let mut s = String::from(
2420 "# magi — blind multi-agent implementation competition.\n\
2421 # `magi run \"<task>\"` walks: implement (N parallel worktrees)\n\
2422 # -> blind judging -> deliberation -> private final vote\n\
2423 # -> fold losers -> review + E2E loop -> gate -> merge.\n\
2424 #\n\
2425 # Rendered by teravars: a `[vars]` table, env\n\
2426 # and system lookups, and `include = [...]` all work. Tera\n\
2427 # braces are live everywhere in this file, but comments are\n\
2428 # stripped before rendering (teravars >= 0.2.2), so a comment\n\
2429 # may quote `{{ ... }}` freely.\n\
2430 #\n\
2431 # Layers deep-merge in increasing\n\
2432 # precedence, so the roster can live once per machine in\n\
2433 # <config_dir>/magi/config.toml and each repo only states its own\n\
2434 # gate:\n\
2435 # <config_dir>/magi/config.toml < .magi/config.toml < magi.toml\n\n\
2436 [vars]\n\
2437 # Reference it as vars.cache inside Tera braces, anywhere below.\n\
2438 # Single quotes inside the braces: teravars renders the raw file\n\
2439 # text, so TOML's own \\\" escaping never reaches Tera.\n\
2440 cache = \"{{ env.MAGI_CACHE | default(value='/tmp') }}\"\n\n",
2441 );
2442 if detected.agents.is_empty() {
2443 s.push_str(
2444 "# No agent CLI was found on PATH. Fill this in by hand.\n\
2445 # kind = claude | opencode | antigravity | codex | command\n\
2446 [[agents]]\nid = \"opus\"\nkind = \"claude\"\nmodel = \"opus\"\n\n",
2447 );
2448 } else {
2449 for a in &detected.agents {
2450 s.push_str("[[agents]]\n");
2451 s.push_str(&format!("id = {:?}\n", a.id));
2452 s.push_str(&format!("kind = {:?}\n", a.kind.as_str()));
2453 if let Some(m) = &a.model {
2454 s.push_str(&format!("model = {m:?}\n"));
2455 }
2456 s.push('\n');
2457 }
2458 }
2459 s.push_str(
2460 "# Leave a role list empty to rotate through the roster.\n\
2461 # A non-empty list is also an ordered backup list: seats take entries from the\n\
2462 # front (see [graph] counts) and a failed or out-of-quota seat moves on to the\n\
2463 # next agent to its right, each tried once. Same for judges and reviewers.\n\
2464 # implementers = [\"opus\", \"codex\", \"sonnet\"] # with implementers = 1 below: opus sits, codex then sonnet are spares\n\
2465 [roles]\n\
2466 implementers = []\n\
2467 judges = []\n\
2468 reviewers = []\n\
2469 # conductor = \"opus\" # arranges the queue; unset picks a seat like chatter does\n\
2470 # synthesizer = \"opus\" # blends the advisors into one brief; unset picks a seat like chatter does\n\
2471 # synthesizer = [\"opus\", \"codex\"] # array form: fallback chain, each tried once on quota or failure\n\
2472 # language_judge = \"jev\" # kind = \"command\" wrapper deciding if PR text is English; unset keeps the built-in heuristics\n\
2473 # dupes_judge = \"opus\" # judges duplicate-work claims; unset inherits chatter (string or fallback chain)\n\
2474 # fixer = \"opus\" # applies review findings; unset keeps the winner's own author\n\
2475 # fixer = [\"opus\", \"codex\"] # array form: fallback chain, each tried once on quota or failure\n\n\
2476 [graph]\n\
2477 # Gate GitHub prose; secret redaction is always enabled.\n\
2478 github_text_guard = true\n\
2479 # Language of PR / issue titles, bodies and comments; non-English drops the English-only check (commits stay English).\n\
2480 github_language = \"en\"\n\
2481 implementers = 3\n\
2482 judges = 3\n\
2483 deliberate_rounds = 1\n\
2484 reviewers = 3\n\
2485 review_rounds = 6\n\
2486 # Fix rounds a failing verify.gate gets before the run is blocked (0 = none).\n\
2487 gate_fix_rounds = 1\n\
2488 # Rerun a failed required CI check once before a land fix round (flaky tests).\n\
2489 rerun_flaky_checks = true\n\
2490 # Port the strengths judges named in the losing candidates onto the\n\
2491 # winner before review (best-effort; rolled back on failure or a big diff).\n\
2492 graft_runner_up = true\n\
2493 max_parallel = 4\n\
2494 language = \"en\"\n\
2495 # One CLI conversation per seat: judges keep their own argument\n\
2496 # across deliberation, the fixer keeps its implementation context.\n\
2497 sessions = true\n\
2498 # Reviewer-seat timeout. When timeout_verify is omitted, E2E and\n\
2499 # the final gate inherit this value for compatibility.\n\
2500 timeout_review = 1200\n\
2501 # Optional independent E2E/final-gate timeout; uncomment to keep\n\
2502 # verification independent if timeout_review changes later.\n\
2503 # timeout_verify = 1200\n\
2504 # Longest a seat waits for the shared build cache before it is\n\
2505 # spawned. Never counted against an agent's own timeout; expiry\n\
2506 # holds the run (resumable) instead of failing the agent.\n\
2507 # timeout_resource_wait = 1800\n\n\
2508 # What the chat calls you (persona address and the Chat's turn label).\n\
2509 # [talk]\n\
2510 # operator_name = \"Commander\"\n\n\
2511 # Chat personas (tone only; the web Chat picks one per conversation).\n\
2512 # Built in: magi, rei, misato, ritsuko, shinji, asuka, kaworu. Entries add to\n\
2513 # them, and one with a built-in's id replaces it. `default` is the plain\n\
2514 # voice and cannot be redefined (it may only set `icon`). Declare this in one\n\
2515 # layer only. `icon` is an optional avatar, display only: an absolute or\n\
2516 # ~/ path to a png/jpg/gif/webp, or a data:image/...;base64 URI, up to\n\
2517 # 256 KiB; a missing or bad one falls back to the built-in avatar.\n\
2518 # [[talk.personas]]\n\
2519 # id = \"gendo\"\n\
2520 # name = \"Gendo Ikari\"\n\
2521 # prompt = \"Speak coldly and tersely, hands folded.\"\n\
2522 # icon = \"~/pictures/gendo.png\"\n\n\
2523 [verify]\n\
2524 # Run once per review round in the winner's worktree; failures are\n\
2525 # fed back to the fixer.\n\
2526 e2e = []\n\
2527 # Final gate. Every command must exit 0 before a merge.\n\
2528 gate = []\n\
2529 # Mechanical fixers (formatters) run in the winner's worktree before\n\
2530 # e2e and before the gate; whatever they change becomes one commit. A\n\
2531 # failing command only warns - the gate stays the arbiter. Same timeout\n\
2532 # as the gate (timeout_verify). Keep it light and idempotent.\n\
2533 # pre_gate = []\n\n\
2534 # Prepare each worktree magi creates (candidates, judges, advisors,\n\
2535 # reviewers, the operator-fix and review-takeover checkouts), in order,\n\
2536 # before any agent or verify command touches it. `copy` reads from the\n\
2537 # primary checkout and never overwrites; `optional` skips a missing\n\
2538 # source. `run` goes through the shell with the worktree as cwd and\n\
2539 # fails the seat on a non-zero exit or timeout (timeout_secs, default\n\
2540 # the verify timeout). Setup must not edit tracked files, and what it\n\
2541 # leaves untracked is kept out of magi's commits. Declare this in one\n\
2542 # layer only.\n\
2543 # [worktree]\n\
2544 # setup = [\n\
2545 # { copy = \".env.example -> .env\" },\n\
2546 # { copy = \".env.local\", optional = true },\n\
2547 # { run = \"pnpm install --frozen-lockfile\", timeout_secs = 900 },\n\
2548 # ]\n\
2549 # pre_clean = [] # Repeatable cleanup before owned clean -fdx.\n\n\
2550 [merge]\n\
2551 # none | local | pr\n\
2552 mode = \"none\"\n\
2553 # expected (default) | none. Set none only in repository config without CI.\n\
2554 # Ignores all check statuses; reviews and approval still apply.\n\
2555 # ci = \"expected\"\n\
2556 # release_bump = true # Rust (Cargo.toml) repositories only; a no-op elsewhere\n\n\
2557 [update]\n\
2558 # off | notify | install — checked in the background, throttled.\n\
2559 mode = \"notify\"\n\
2560 # interval = \"24h\"\n\n\
2561 # Opt-in: magi web updates and restarts only after runs/chats finish.\n\
2562 # auto_restart = false\n\
2563 # Uses interval above; off / MAGI_NO_AUTOUPDATE disable it.\n\
2564 # Standalone magi serve cannot restart. Busy work waits indefinitely.\n\
2565 # Failed tags are skipped until process restart or a different tag.\n\
2566 # Older binaries reject auto_restart: upgrade before adding the key.\n\n\
2567 [daemon]\n\
2568 # Minutes a release-bump pull request (chore/release-v*) may sit with\n\
2569 # no new commit and no check changing state before `magi serve`\n\
2570 # notices and asks you. A failed check is rerun once on its own;\n\
2571 # still red after that escalates at once. 0 turns the watcher off.\n\
2572 # release_stall_minutes = 60\n\n\
2573 [release]\n\
2574 # actions (default) | local. \"local\" is for repositories whose GitHub\n\
2575 # Actions never run (private, no minutes): the release pull request\n\
2576 # does not wait for CI, you approve the merge in magi, and then\n\
2577 # `magi serve` pushes the vX.Y.Z tag (never over an existing one) and\n\
2578 # runs `commands` from a clean checkout of the merge commit. A\n\
2579 # failure holds the release with a notice; it is never retried blind.\n\
2580 # Needs `magi serve` running and [daemon] release_stall_minutes > 0.\n\
2581 # For ordinary pull requests without CI, also set [merge] ci = \"none\".\n\
2582 # mode = \"actions\"\n\
2583 # Run in order; the first failure stops. They see MAGI_RELEASE_VERSION,\n\
2584 # MAGI_RELEASE_TAG, MAGI_RELEASE_COMMIT and MAGI_RELEASE_PR. Make them\n\
2585 # safe to repeat: a crash mid-command is treated as unfinished.\n\
2586 # commands = [\"cargo build --release\", \"gh release create \\\"$MAGI_RELEASE_TAG\\\" --generate-notes\"]\n\
2587 # timeout_minutes = 30\n\
2588 # Repositories whose Cargo.toml is not at the root (e.g. a Tauri app).\n\
2589 # The first entry is the version of record and must be the file the\n\
2590 # repository's auto-tag.yml reads (kind \"cargo\"); the others are\n\
2591 # rewritten to the same version. Paths are relative to the repository\n\
2592 # root. Cargo.lock beside the first entry follows; package-lock.json\n\
2593 # is not touched.\n\
2594 # version_files = [\n\
2595 # { path = \"src-tauri/Cargo.toml\", kind = \"cargo\" },\n\
2596 # { path = \"package.json\", kind = \"json\" },\n\
2597 # { path = \"src-tauri/tauri.conf.json\", kind = \"json\" },\n\
2598 # ]\n",
2599 );
2600 s
2601 }
2602}
2603
2604pub fn which(program: &str) -> bool {
2606 find_program(program).is_some()
2607}
2608
2609pub fn find_program(program: &str) -> Option<PathBuf> {
2618 find_program_on(program, &std::env::var_os("PATH")?)
2619}
2620
2621pub fn find_program_on(program: &str, paths: &std::ffi::OsStr) -> Option<PathBuf> {
2624 let pathext = std::env::var("PATHEXT").unwrap_or_else(|_| ".EXE;.CMD;.BAT".into());
2625 find_program_in(program, paths, cfg!(windows).then_some(pathext.as_str()))
2626}
2627
2628fn find_program_in(
2629 program: &str,
2630 paths: &std::ffi::OsStr,
2631 pathext: Option<&str>,
2632) -> Option<PathBuf> {
2633 let p = Path::new(program);
2634 if p.components().count() > 1 {
2635 return p.is_file().then(|| p.to_path_buf());
2636 }
2637 std::env::split_paths(paths).find_map(|dir| match pathext {
2638 Some(exts) => {
2639 let bare = dir.join(program);
2640 if p.extension().is_some() && bare.is_file() {
2641 return Some(bare);
2642 }
2643 exts.split(';')
2644 .filter(|e| !e.is_empty())
2645 .map(|e| dir.join(format!("{program}{}", e.to_lowercase())))
2646 .find(|c| c.is_file())
2647 }
2648 None => Some(dir.join(program)).filter(|c| c.is_file()),
2649 })
2650}
2651
2652const REPO_MARKER: &str = ".magi-repo";
2654
2655fn git_out(repo: &Path, args: &[&str]) -> Option<String> {
2656 use crate::proc::Quiet as _;
2657 #[cfg(test)]
2658 crate::web::request_cost::git();
2659 let out = std::process::Command::new("git")
2660 .args(args)
2661 .quiet()
2662 .current_dir(repo)
2663 .stdin(std::process::Stdio::null())
2664 .output()
2665 .ok()?;
2666 out.status
2667 .success()
2668 .then(|| String::from_utf8_lossy(&out.stdout).into_owned())
2669}
2670
2671fn is_git_worktree(repo: &Path) -> bool {
2674 git_out(repo, &["rev-parse", "--git-dir"]).is_some()
2675}
2676
2677#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
2680pub enum OwnerHold {
2681 LandApproval,
2683 HoldContestedMerge,
2685}
2686
2687impl OwnerHold {
2688 pub const ALL: [Self; 2] = [Self::LandApproval, Self::HoldContestedMerge];
2690
2691 pub fn key(self) -> &'static str {
2693 match self {
2694 Self::LandApproval => "land_approval",
2695 Self::HoldContestedMerge => "hold_contested_merge",
2696 }
2697 }
2698
2699 pub fn base_value(self, graph: &Graph) -> bool {
2701 match self {
2702 Self::LandApproval => graph.land_approval,
2703 Self::HoldContestedMerge => graph.hold_contested_merge,
2704 }
2705 }
2706}
2707
2708pub async fn branch_owner_holds(
2711 repo: &Path,
2712 head: &str,
2713) -> (Vec<(OwnerHold, String)>, Vec<String>) {
2714 let mut holds = Vec::new();
2715 let mut diagnostics = Vec::new();
2716 if let Err(error) =
2719 crate::git::git(repo, &["cat-file", "-e", &format!("{head}^{{commit}}")]).await
2720 {
2721 diagnostics.push(format!("cannot read reviewed commit {head}: {error:#}"));
2722 return (holds, diagnostics);
2723 }
2724 for file in ["magi.toml", ".magi/config.toml"] {
2725 let object = format!("{head}:{file}");
2726 let text = match crate::git::git(repo, &["show", &object]).await {
2727 Ok(text) => text,
2728 Err(error) => {
2729 let error = format!("{error:#}");
2731 if !error.contains("does not exist in")
2732 && !error.contains("exists on disk, but not in")
2733 {
2734 diagnostics.push(format!(
2735 "cannot read reviewed branch {file} at {head}: {error}"
2736 ));
2737 }
2738 continue;
2739 }
2740 };
2741 let value = match toml::from_str::<toml::Value>(&text) {
2742 Ok(value) => value,
2743 Err(error) => {
2744 diagnostics.push(format!(
2745 "cannot parse reviewed branch {file} at {head}: {error}"
2746 ));
2747 continue;
2748 }
2749 };
2750 if value.get("include").is_some() || text.contains("{{") || text.contains("{%") {
2751 diagnostics.push(format!("reviewed branch {file} at {head}: only literal owner holds are read; includes and templates are ignored"));
2752 }
2753 for hold in OwnerHold::ALL {
2754 if value
2755 .get("graph")
2756 .and_then(|g| g.get(hold.key()))
2757 .and_then(toml::Value::as_bool)
2758 == Some(true)
2759 {
2760 holds.push((hold, file.to_owned()));
2761 }
2762 }
2763 }
2764 (holds, diagnostics)
2765}
2766
2767#[derive(Deserialize, Default)]
2768struct ProbeMerge {
2769 base: Option<String>,
2770 remote: Option<String>,
2771}
2772
2773#[derive(Deserialize, Default)]
2774struct Probe {
2775 merge: Option<ProbeMerge>,
2776}
2777
2778fn probe_merge(path: &Path, repo: &Path) -> Option<ProbeMerge> {
2784 if !path.is_file() {
2785 return None;
2786 }
2787 let paths = [path.to_path_buf()];
2788 let mut engine = teravars::Engine::default();
2789 let mut ctx = Config::render_ctx(&paths);
2790 ctx.insert("repo", &repo.to_string_lossy());
2793 ctx.insert(
2794 "repo_name",
2795 &repo.file_name().unwrap_or_default().to_string_lossy(),
2796 );
2797 if let Ok(merged) = teravars::load_merged(&paths, &mut engine, &ctx)
2798 && let Ok(probe) = toml::Value::Table(merged.config).try_into::<Probe>()
2799 {
2800 return probe.merge;
2801 }
2802 let text = std::fs::read_to_string(path).ok()?;
2803 toml::from_str::<Probe>(&text).ok()?.merge
2804}
2805
2806fn probe_remote_base(repo: &Path) -> (String, Option<String>) {
2808 let mut remote = None;
2809 let mut base = None;
2810 let mut sources: Vec<PathBuf> = Config::machine_layer().into_iter().collect();
2811 sources.push(repo.join("magi.toml"));
2812 sources.push(repo.join(".magi").join("config.toml"));
2813 for path in sources {
2814 if let Some(m) = probe_merge(&path, repo) {
2815 remote = remote.or(m.remote.filter(|s| !s.trim().is_empty()));
2816 base = base.or(m.base.filter(|s| !s.trim().is_empty()));
2817 }
2818 }
2819 (remote.unwrap_or_else(|| "origin".to_owned()), base)
2820}
2821
2822fn resolve_remote_base(repo: &Path) -> Result<(String, String)> {
2824 let (remote, base) = probe_remote_base(repo);
2825 let base = match base {
2826 Some(b) => b,
2827 None => {
2828 let head = format!("refs/remotes/{remote}/HEAD");
2829 git_out(repo, &["symbolic-ref", "--quiet", &head])
2830 .and_then(|s| crate::git::remote_head_branch(&remote, &s))
2831 .with_context(|| {
2832 format!(
2833 "cannot tell which branch of `{remote}` holds magi.toml: \
2834 set [merge] base, or run `git remote set-head {remote} -a`"
2835 )
2836 })?
2837 }
2838 };
2839 Ok((remote, base))
2840}
2841
2842fn fnv_hex(text: &str) -> String {
2843 let mut hash: u64 = 0xcbf2_9ce4_8422_2325;
2844 for b in text.bytes() {
2845 hash ^= u64::from(b);
2846 hash = hash.wrapping_mul(0x0100_0000_01b3);
2847 }
2848 format!("{hash:016x}")
2849}
2850
2851fn declares_include(text: &str) -> bool {
2857 match toml::from_str::<toml::Table>(text) {
2858 Ok(table) => {
2859 table.contains_key("include")
2860 || table
2861 .get("teravars")
2862 .and_then(toml::Value::as_table)
2863 .is_some_and(|t| t.contains_key("include"))
2864 }
2865 Err(_) => text.contains("include"),
2866 }
2867}
2868
2869fn extract_tree(repo: &Path, sha: &str, dest: &Path) -> Result<()> {
2872 use crate::proc::Quiet as _;
2873 #[cfg(test)]
2874 crate::web::request_cost::git();
2875 let mut archive = std::process::Command::new("git")
2876 .args(["archive", "--format=tar", sha])
2877 .quiet()
2878 .current_dir(repo)
2879 .stdin(std::process::Stdio::null())
2880 .stdout(std::process::Stdio::piped())
2881 .stderr(std::process::Stdio::null())
2882 .spawn()
2883 .context("running git archive")?;
2884 let tar = std::process::Command::new("tar")
2885 .arg("-x")
2886 .arg("-C")
2887 .arg(dest)
2888 .quiet()
2889 .stdin(archive.stdout.take().context("git archive has no stdout")?)
2890 .output()
2891 .context("running tar")?;
2892 let status = archive.wait().context("waiting for git archive")?;
2893 if !status.success() || !tar.status.success() {
2894 bail!(
2895 "cannot unpack {sha} for the config's includes: {}",
2896 String::from_utf8_lossy(&tar.stderr).trim()
2897 );
2898 }
2899 Ok(())
2900}
2901
2902fn remote_layers(repo: &Path) -> Result<Vec<PathBuf>> {
2905 let (remote, base) = resolve_remote_base(repo)?;
2906 let tracking = format!("refs/remotes/{remote}/{base}");
2907 let spec = format!("{tracking}^{{commit}}");
2908 let sha = git_out(repo, &["rev-parse", "--verify", "--quiet", &spec])
2909 .map(|s| s.trim().to_owned())
2910 .filter(|s| !s.is_empty())
2911 .with_context(|| {
2912 format!(
2913 "`{remote}/{base}` does not exist in this checkout; fetch it \
2914 (`git fetch {remote} {base}`) or set [merge] base/remote. magi will not read \
2915 a possibly stale local magi.toml instead"
2916 )
2917 })?;
2918 let key = format!("{sha}-{}", fnv_hex(&repo.to_string_lossy()));
2919 let rels = [".magi/config.toml", "magi.toml"];
2920 let mut texts: Vec<(&str, String)> = Vec::new();
2921 for rel in rels {
2922 let object = format!("{sha}:{rel}");
2923 if git_out(repo, &["cat-file", "-e", &object]).is_none() {
2924 continue;
2925 }
2926 let Some(text) = git_out(repo, &["show", &object]) else {
2927 bail!("cannot read {rel} from {remote}/{base} ({sha})");
2928 };
2929 texts.push((rel, text));
2930 }
2931 let wants_tree = texts.iter().any(|(_, t)| declares_include(t));
2932 let build = |root: &Path| -> Result<PathBuf> {
2936 let final_dir = root.join(&key);
2937 if !final_dir.is_dir() {
2938 std::fs::create_dir_all(root)?;
2939 let tmp = root.join(format!(
2940 "{key}.tmp-{}-{}",
2941 std::process::id(),
2942 std::time::SystemTime::now()
2943 .duration_since(std::time::UNIX_EPOCH)
2944 .map(|d| d.as_nanos())
2945 .unwrap_or_default()
2946 ));
2947 let filled = (|| -> Result<()> {
2948 std::fs::create_dir_all(&tmp)?;
2949 if wants_tree {
2950 extract_tree(repo, &sha, &tmp)?;
2951 }
2952 for (rel, text) in &texts {
2953 let file = tmp.join(rel);
2954 let parent = file.parent().unwrap_or(&tmp);
2955 std::fs::create_dir_all(parent)?;
2956 std::fs::write(&file, text)?;
2957 std::fs::write(parent.join(REPO_MARKER), repo.to_string_lossy().as_bytes())?;
2958 }
2959 Ok(())
2960 })();
2961 if let Err(e) = filled {
2962 let _ = std::fs::remove_dir_all(&tmp);
2963 return Err(e);
2964 }
2965 if std::fs::rename(&tmp, &final_dir).is_err() {
2966 let _ = std::fs::remove_dir_all(&tmp);
2968 if !final_dir.is_dir() {
2969 bail!("cannot place {}", final_dir.display());
2970 }
2971 }
2972 }
2973 Ok(final_dir)
2974 };
2975 let common = git_out(
2976 repo,
2977 &["rev-parse", "--path-format=absolute", "--git-common-dir"],
2978 )
2979 .map(|s| PathBuf::from(s.trim()).join("magi").join("config"));
2980 let dir = match common.map(|c| build(&c)) {
2981 Some(Ok(d)) => d,
2982 _ => build(&std::env::temp_dir().join("magi-config"))
2983 .with_context(|| format!("extracting config from {remote}/{base}"))?,
2984 };
2985 Ok(texts.iter().map(|(rel, _)| dir.join(rel)).collect())
2986}
2987
2988#[cfg(test)]
2989mod tests {
2990 #[test]
2991 fn run_records_with_the_retired_editing_network_key_still_load() {
2992 for value in ["enabled", "restricted"] {
2994 let mut graph = serde_json::to_value(Graph::default()).unwrap();
2995 graph["editing_network"] = serde_json::json!(value);
2996 let back: Graph = serde_json::from_value(graph).unwrap();
2997 assert!(
2998 serde_json::to_value(&back)
2999 .unwrap()
3000 .get("editing_network")
3001 .is_none()
3002 );
3003 let from_toml: Graph = toml::from_str(&format!("editing_network = {value:?}")).unwrap();
3004 assert!(
3005 !toml::to_string(&from_toml)
3006 .unwrap()
3007 .contains("editing_network")
3008 );
3009 }
3010 }
3011
3012 #[test]
3013 fn coordination_defaults_off_and_validates_rendered_layer_values() {
3014 let dir = tempfile::tempdir().unwrap();
3015 let machine = dir.path().join("machine.toml");
3016 let repo = dir.path().join("repo.toml");
3017 std::fs::write(&machine, "").unwrap();
3018 assert!(Config::default().coordination.is_none());
3019 assert!(Config::load(&machine).unwrap().coordination.is_none());
3020 std::fs::write(
3021 &machine,
3022 r#"
3023[vars]
3024contract = "updater.contract"
3025[coordination]
3026contract_file = "{{ vars.contract }}"
3027contract_token = "protocol-v1"
3028lock_file = "updater.lock"
3029"#,
3030 )
3031 .unwrap();
3032 let cfg = Config::load(&machine).unwrap();
3033 let policy = cfg.coordination.unwrap();
3034 assert_eq!(policy.contract_file, "updater.contract");
3035 assert_eq!(policy.contract_token, "protocol-v1");
3036 assert_eq!(policy.lock_file, "updater.lock");
3037 std::fs::write(&repo, "[coordination]\nlock_file = 'repository.lock'\n").unwrap();
3038 let cfg = Config::load_layers(&[machine.clone(), repo.clone()]).unwrap();
3039 let policy = cfg.coordination.unwrap();
3040 assert_eq!(policy.contract_file, "updater.contract");
3041 assert_eq!(policy.lock_file, "repository.lock");
3042 std::fs::write(
3043 &repo,
3044 r#"
3045[vars]
3046bad = "../escape"
3047[coordination]
3048lock_file = "{{ vars.bad }}"
3049"#,
3050 )
3051 .unwrap();
3052 let error = Config::load_layers(&[machine, repo]).unwrap_err();
3053 assert!(format!("{error:#}").contains("coordination.lock_file"));
3054 }
3055
3056 #[test]
3057 fn coordination_rejects_invalid_names_tokens_and_incomplete_sections() {
3058 let dir = tempfile::tempdir().unwrap();
3059 let path = dir.path().join("config.toml");
3060 let valid = toml::toml! {
3061 [coordination]
3062 contract_file = "updater.contract"
3063 contract_token = "protocol-v1"
3064 lock_file = "updater.lock"
3065 };
3066 for key in ["contract_file", "lock_file"] {
3067 for bad in [
3068 "",
3069 " ",
3070 " file",
3071 "file ",
3072 "\tfile",
3073 "file\t",
3074 ".",
3075 "..",
3076 "file..name",
3077 "../escape",
3078 "a/b",
3079 "a\\b",
3080 "/absolute",
3081 "C:drive",
3082 "C:\\absolute",
3083 "nul\0name",
3084 ] {
3085 let mut table = valid.clone();
3086 table["coordination"][key] = bad.into();
3087 std::fs::write(&path, toml::to_string(&table).unwrap()).unwrap();
3088 let error = Config::load(&path).unwrap_err();
3089 assert!(
3090 format!("{error:#}").contains(&format!("coordination.{key}")),
3091 "{bad:?}: {error:#}"
3092 );
3093 }
3094 }
3095 for bad in ["", " ", " token", "token ", "two\nlines", "two\rlines"] {
3096 let mut table = valid.clone();
3097 table["coordination"]["contract_token"] = bad.into();
3098 std::fs::write(&path, toml::to_string(&table).unwrap()).unwrap();
3099 let error = Config::load(&path).unwrap_err();
3100 assert!(
3101 format!("{error:#}").contains("coordination.contract_token"),
3102 "{error:#}"
3103 );
3104 }
3105 for key in ["contract_file", "contract_token", "lock_file"] {
3106 let mut table = valid.clone();
3107 table["coordination"].as_table_mut().unwrap().remove(key);
3108 std::fs::write(&path, toml::to_string(&table).unwrap()).unwrap();
3109 let error = Config::load(&path).unwrap_err();
3110 assert!(
3111 format!("{error:#}").contains(&format!("coordination.{key}")),
3112 "{error:#}"
3113 );
3114 }
3115 let mut table = valid;
3116 table["coordination"]
3117 .as_table_mut()
3118 .unwrap()
3119 .insert("typo".into(), "value".into());
3120 std::fs::write(&path, toml::to_string(&table).unwrap()).unwrap();
3121 assert!(format!("{:#}", Config::load(&path).unwrap_err()).contains("typo"));
3122 }
3123
3124 #[test]
3125 fn context_window_prefers_exact_then_longest_prefix_and_user_over_builtin() {
3126 let mut cfg = Config::default();
3127 assert_eq!(
3128 cfg.context_window("claude-sonnet-4-5-20250929"),
3129 Some(200_000)
3130 );
3131 assert_eq!(cfg.context_window("gpt-4.1-mini"), Some(1_000_000));
3132 assert_eq!(cfg.context_window("mystery-model"), None);
3133 cfg.context_windows
3134 .insert("claude-sonnet-4-5".into(), 1_000_000);
3135 cfg.context_windows.insert("claude-sonnet-4".into(), 5);
3136 cfg.context_windows.insert("mystery".into(), 32_768);
3137 assert_eq!(
3139 cfg.context_window("claude-sonnet-4-5-20250929"),
3140 Some(1_000_000)
3141 );
3142 cfg.context_windows
3144 .insert("claude-sonnet-4-5-20250929".into(), 7);
3145 assert_eq!(cfg.context_window("claude-sonnet-4-5-20250929"), Some(7));
3146 assert_eq!(cfg.context_window("mystery-model"), Some(32_768));
3147 }
3148
3149 use super::*;
3150
3151 #[test]
3154 fn windows_lookup_picks_the_cmd_shim_over_the_extensionless_script() {
3155 let dir = tempfile::tempdir().unwrap();
3156 std::fs::write(dir.path().join("codex"), "#!/bin/sh\n").unwrap();
3157 std::fs::write(dir.path().join("codex.cmd"), "@echo off\n").unwrap();
3158 let paths = dir.path().as_os_str();
3159 assert_eq!(
3160 find_program_in("codex", paths, Some(".EXE;.CMD")),
3161 Some(dir.path().join("codex.cmd"))
3162 );
3163 assert_eq!(
3164 find_program_in("codex", paths, None),
3165 Some(dir.path().join("codex"))
3166 );
3167 assert_eq!(find_program_in("claude", paths, Some(".EXE;.CMD")), None);
3168 }
3169
3170 fn spec(id: &str) -> AgentSpec {
3171 AgentSpec {
3172 id: id.to_owned(),
3173 kind: AgentKind::Command,
3174 model: None,
3175 command: vec!["true".to_owned()],
3176 extra_args: Vec::new(),
3177 env: BTreeMap::new(),
3178 prompt_delivery: None,
3179 max_turn_secs: None,
3180 }
3181 }
3182
3183 #[test]
3184 fn merge_ci_defaults_expected_and_requires_an_explicit_valid_opt_out() {
3185 let default: Merge = toml::from_str("").unwrap();
3186 assert_eq!(default.ci, MergeCi::Expected);
3187 let config = layered("", "[merge]\nci = \"none\"\n").unwrap();
3188 assert_eq!(
3189 config.merge.ci.expectation(),
3190 crate::land::CiExpectation::Absent
3191 );
3192 assert!(toml::from_str::<Merge>("ci = \"typo\"").is_err());
3193 assert!(Config::starter_toml().contains("# ci = \"expected\""));
3194 }
3195
3196 #[test]
3197 fn github_text_guard_defaults_on_and_can_be_disabled() {
3198 let default: Graph = toml::from_str("").unwrap();
3199 assert!(default.github_text_guard);
3200 let disabled: Graph = toml::from_str("github_text_guard = false").unwrap();
3201 assert!(!disabled.github_text_guard);
3202 let config = layered("", "[graph]\ngithub_text_guard = false\n").unwrap();
3203 assert!(!config.graph.github_text_guard);
3204 assert!(Config::starter_toml().contains("github_text_guard = true"));
3205 }
3206
3207 #[test]
3208 fn rerun_flaky_checks_defaults_on_and_is_in_the_starter() {
3209 assert!(Graph::default().rerun_flaky_checks);
3210 let off: Graph = toml::from_str("rerun_flaky_checks = false").unwrap();
3211 assert!(!off.rerun_flaky_checks);
3212 assert!(Config::starter_toml().contains("rerun_flaky_checks = true"));
3213 }
3214
3215 #[test]
3216 fn timeout_verify_omitted_from_old_toml_inherits_timeout_review() {
3217 let g: Graph = toml::from_str("timeout_review = 3600").expect("parse");
3222 assert_eq!(g.timeout_verify, None);
3223 assert_eq!(g.verify_timeout(), 3600);
3224 }
3225
3226 #[test]
3227 fn shrinking_timeout_review_does_not_shrink_timeout_verify() {
3228 let g: Graph = toml::from_str("timeout_review = 45").expect("parse");
3233 assert_eq!(g.timeout_review, 45);
3234 assert_eq!(
3235 g.verify_timeout(),
3236 45,
3237 "an omitted legacy value follows review"
3238 );
3239 let explicit: Graph = toml::from_str("timeout_review = 45\ntimeout_verify = 1200")
3240 .expect("parse explicit override");
3241 assert_eq!(explicit.verify_timeout(), 1200);
3242 }
3243
3244 #[test]
3245 fn graph_implementers_new_key_loads_and_old_key_is_an_alias() {
3246 let g: Graph = toml::from_str("implementers = 4\n").unwrap();
3247 assert_eq!(g.implementers, 4);
3248 let g: Graph = toml::from_str("candidates = 5\n").unwrap();
3249 assert_eq!(g.implementers, 5);
3250 }
3251
3252 fn layered(lower: &str, upper: &str) -> Result<Config> {
3253 let dir = tempfile::tempdir().unwrap();
3254 let a = dir.path().join("a.toml");
3255 let b = dir.path().join("b.toml");
3256 std::fs::write(&a, lower).unwrap();
3257 std::fs::write(&b, upper).unwrap();
3258 Config::load_layers(&[a, b])
3259 }
3260
3261 #[test]
3262 fn graph_implementers_higher_layer_wins_across_spellings() {
3263 let c = layered("[graph]\ncandidates = 2\n", "[graph]\nimplementers = 5\n").unwrap();
3264 assert_eq!(c.graph.implementers, 5);
3265 let c = layered("[graph]\nimplementers = 2\n", "[graph]\ncandidates = 5\n").unwrap();
3266 assert_eq!(c.graph.implementers, 5);
3267 let c = layered("[graph]\ncandidates = 2\n", "[graph]\njudges = 3\n").unwrap();
3268 assert_eq!(c.graph.implementers, 2);
3269 }
3270
3271 #[test]
3272 fn graph_implementers_both_keys_in_one_layer_is_refused() {
3273 let err = layered("", "[graph]\ncandidates = 2\nimplementers = 3\n")
3274 .unwrap_err()
3275 .to_string();
3276 assert!(
3277 err.contains("candidates") && err.contains("implementers"),
3278 "{err}"
3279 );
3280 assert!(err.contains("b.toml"), "{err}");
3281 }
3282
3283 #[test]
3284 fn a_toml_layer_written_before_these_fields_existed_still_parses() {
3285 let g: Graph =
3289 toml::from_str("candidates = 1\nreviewers = 3\nreview_rounds = 6\nmax_parallel = 4\n")
3290 .expect("an old-shaped [graph] table must still parse");
3291 assert_eq!(g.verify_timeout(), Graph::default().timeout_review);
3292 assert!(
3293 !g.e2e_every_round,
3294 "off by default, same as before this field existed"
3295 );
3296 }
3297
3298 #[test]
3299 fn empty_roles_rotate_judges_off_their_own_candidate() {
3300 let cfg = Config {
3303 agents: vec![spec("a"), spec("b"), spec("c")],
3304 graph: Graph {
3305 implementers: 3,
3306 ..Graph::default()
3307 },
3308 ..Config::default()
3309 };
3310 let roles = cfg.resolve_roles().unwrap();
3311 let impls: Vec<&str> = roles.implementers.iter().map(|a| a.id.as_str()).collect();
3312 let judges: Vec<&str> = roles.judges.iter().map(|a| a.id.as_str()).collect();
3313 assert_eq!(impls, ["a", "b", "c"]);
3314 assert_eq!(judges, ["b", "c", "a"]);
3315 for (i, j) in judges.iter().enumerate() {
3316 assert_ne!(*j, impls[i], "judge {i} must not sit on its own candidate");
3317 }
3318 }
3319
3320 #[test]
3321 fn single_agent_roster_fills_every_seat() {
3322 let cfg = Config {
3323 agents: vec![spec("solo")],
3324 graph: Graph {
3325 implementers: 3,
3326 ..Graph::default()
3327 },
3328 ..Config::default()
3329 };
3330 let roles = cfg.resolve_roles().unwrap();
3331 assert_eq!(roles.implementers.len(), 3);
3332 assert!(roles.judges.iter().all(|a| a.id == "solo"));
3333 }
3334
3335 #[test]
3336 fn implementer_roster_is_the_whole_agent_list_untruncated_when_unset() {
3337 let cfg = Config {
3342 agents: vec![spec("a"), spec("b"), spec("c")],
3343 graph: Graph {
3344 implementers: 1,
3345 ..Graph::default()
3346 },
3347 ..Config::default()
3348 };
3349 let roles = cfg.resolve_roles().unwrap();
3350 assert_eq!(roles.implementers.len(), 1);
3351 let roster: Vec<&str> = roles
3352 .implementer_roster
3353 .iter()
3354 .map(|a| a.id.as_str())
3355 .collect();
3356 assert_eq!(roster, ["a", "b", "c"]);
3357 }
3358
3359 #[test]
3360 fn implementer_roster_follows_explicit_ids_in_the_order_named() {
3361 let cfg = Config {
3362 agents: vec![spec("a"), spec("b"), spec("c")],
3363 roles: Roles {
3364 implementers: vec!["c".to_owned(), "a".to_owned()],
3365 ..Roles::default()
3366 },
3367 graph: Graph {
3368 implementers: 1,
3369 ..Graph::default()
3370 },
3371 ..Config::default()
3372 };
3373 let roles = cfg.resolve_roles().unwrap();
3374 assert_eq!(roles.implementers.len(), 1);
3376 assert_eq!(roles.implementers[0].id, "c");
3377 let roster: Vec<&str> = roles
3378 .implementer_roster
3379 .iter()
3380 .map(|a| a.id.as_str())
3381 .collect();
3382 assert_eq!(roster, ["c", "a"]);
3383 }
3384
3385 #[test]
3386 fn explicit_roles_win() {
3387 let cfg = Config {
3388 agents: vec![spec("a"), spec("b")],
3389 roles: Roles {
3390 implementers: vec!["b".to_owned()],
3391 judges: vec!["a".to_owned()],
3392 reviewers: Vec::new(),
3393 fixer: Some("a".into()),
3394 ..Roles::default()
3395 },
3396 ..Config::default()
3397 };
3398 let roles = cfg.resolve_roles().unwrap();
3399 assert!(roles.implementers.iter().all(|a| a.id == "b"));
3400 assert!(roles.judges.iter().all(|a| a.id == "a"));
3401 let fixer = roles.fixer.unwrap();
3402 assert_eq!(fixer.len(), 1);
3403 assert_eq!(fixer[0].id, "a");
3404 assert_eq!(roles.conductor.id, "a");
3405 }
3406
3407 #[test]
3408 fn fixer_takes_a_string_or_an_ordered_chain() {
3409 let one: Roles = toml::from_str("fixer = \"a\"").unwrap();
3410 assert_eq!(one.fixer.as_ref().unwrap().ids(), ["a"]);
3411 let chain: Roles = toml::from_str("fixer = [\"b\", \"a\"]").unwrap();
3412 assert_eq!(chain.fixer.as_ref().unwrap().ids(), ["b", "a"]);
3413
3414 let resolve = |fixer: Option<AgentChoice>| {
3415 Config {
3416 agents: vec![spec("a"), spec("b"), spec("c")],
3417 roles: Roles {
3418 fixer,
3419 ..Roles::default()
3420 },
3421 ..Config::default()
3422 }
3423 .resolve_roles()
3424 };
3425 let ids = |r: &ResolvedRoles| -> Vec<String> {
3426 r.fixer
3427 .as_ref()
3428 .unwrap()
3429 .iter()
3430 .map(|s| s.id.clone())
3431 .collect()
3432 };
3433 assert_eq!(ids(&resolve(Some("c".into())).unwrap()), ["c"]);
3435 assert!(resolve(None).unwrap().fixer.is_none());
3436 let chain = AgentChoice::Chain(vec!["b".into(), "zzz".into(), "a".into(), "b".into()]);
3438 assert_eq!(ids(&resolve(Some(chain)).unwrap()), ["b", "a"]);
3439 let err = resolve(Some(AgentChoice::Chain(vec!["zzz".into()]))).unwrap_err();
3441 assert!(format!("{err:#}").contains("fixer"), "{err:#}");
3442 }
3443
3444 #[test]
3445 fn unknown_agent_id_is_an_error() {
3446 let cfg = Config {
3447 agents: vec![spec("a")],
3448 roles: Roles {
3449 judges: vec!["nope".to_owned()],
3450 ..Roles::default()
3451 },
3452 ..Config::default()
3453 };
3454 assert!(cfg.resolve_roles().is_err());
3455 }
3456
3457 #[test]
3458 fn conductor_role_is_resolved_validated_and_has_a_fallback() {
3459 let mut cfg = Config {
3460 agents: vec![spec("a"), spec("b")],
3461 ..Config::default()
3462 };
3463 assert_eq!(cfg.resolve_roles().unwrap().conductor.id, "a");
3464
3465 cfg.roles.conductor = Some("b".into());
3466 assert_eq!(cfg.resolve_roles().unwrap().conductor.id, "b");
3467
3468 cfg.roles.conductor = Some("missing".into());
3469 assert!(cfg.resolve_roles().is_err());
3470 }
3471
3472 #[test]
3473 fn a_standalone_role_takes_a_string_or_an_array_and_round_trips() {
3474 let one: Roles = toml::from_str("synthesizer = \"opus\"").unwrap();
3475 assert_eq!(one.synthesizer, Some(AgentChoice::One("opus".to_owned())));
3476 assert_eq!(primary(one.synthesizer.as_ref()), Some("opus"));
3477
3478 let chain: Roles = toml::from_str("chatter = [\"opus\", \"codex\"]").unwrap();
3479 assert_eq!(chain.chatter.as_ref().unwrap().ids(), ["opus", "codex"]);
3480 assert_eq!(primary(chain.chatter.as_ref()), Some("opus"));
3481
3482 for roles in [one, chain] {
3483 let text = toml::to_string(&roles).unwrap();
3484 let back: Roles = toml::from_str(&text).unwrap();
3485 assert_eq!(back.synthesizer, roles.synthesizer);
3486 assert_eq!(back.chatter, roles.chatter);
3487 }
3488 let text = toml::to_string(&Roles {
3489 conductor: Some("x".into()),
3490 ..Roles::default()
3491 })
3492 .unwrap();
3493 assert!(
3494 text.contains("conductor = \"x\""),
3495 "string stays a string: {text}"
3496 );
3497 assert!(toml::from_str::<Roles>("synthesizer = 3").is_err());
3498 }
3499
3500 #[test]
3501 fn dupes_judge_role_accepts_strings_and_chains_and_round_trips() {
3502 for (text, ids) in [
3503 (r#"dupes_judge = "dedicated""#, vec!["dedicated"]),
3504 (
3505 r#"dupes_judge = ["first", "second"]"#,
3506 vec!["first", "second"],
3507 ),
3508 ("dupes_judge = []", vec![]),
3509 ] {
3510 let roles: Roles = toml::from_str(text).unwrap();
3511 assert_eq!(roles.dupes_judge.as_ref().unwrap().ids(), ids);
3512 let serialized = toml::to_string(&roles).unwrap();
3513 let back: Roles = toml::from_str(&serialized).unwrap();
3514 assert_eq!(back.dupes_judge, roles.dupes_judge);
3515 assert!(serialized.contains(text));
3516 }
3517 assert!(toml::from_str::<Roles>("dupes_judge = 3").is_err());
3518 assert!(Roles::default().dupes_judge.is_none());
3519 assert!(Config::starter_toml().contains("# dupes_judge ="));
3520
3521 let mut cfg = Config {
3523 agents: vec![spec("a")],
3524 ..Config::default()
3525 };
3526 cfg.roles.dupes_judge = Some("missing".into());
3527 assert!(cfg.resolve_roles().is_ok());
3528 }
3529
3530 #[test]
3531 fn an_empty_choice_counts_as_unset() {
3532 assert!(AgentChoice::Chain(Vec::new()).ids().is_empty());
3533 assert!(AgentChoice::One(" ".to_owned()).ids().is_empty());
3534 assert_eq!(primary(Some(&AgentChoice::Chain(vec![]))), None);
3535 }
3536
3537 #[test]
3538 fn synthesizer_role_is_a_lazy_lookup_with_the_same_fallback_as_chatter() {
3539 let mut cfg = Config {
3545 agents: vec![spec("a"), spec("b")],
3546 ..Config::default()
3547 };
3548 let want = primary(cfg.roles.synthesizer.as_ref());
3549 assert_eq!(
3550 crate::agent::pick(&cfg.agents, want, &crate::agent::installed)
3551 .unwrap()
3552 .id,
3553 "a",
3554 "unset falls back to agent::pick's own default order"
3555 );
3556
3557 cfg.roles.synthesizer = Some("b".into());
3558 let want = primary(cfg.roles.synthesizer.as_ref());
3559 assert_eq!(
3560 crate::agent::pick(&cfg.agents, want, &crate::agent::installed)
3561 .unwrap()
3562 .id,
3563 "b",
3564 "the named agent wins over the default order"
3565 );
3566 }
3567
3568 #[test]
3569 fn empty_roster_is_an_error() {
3570 assert!(Config::default().resolve_roles().is_err());
3571 }
3572
3573 #[test]
3574 fn advise_defaults_to_on_with_three_proposals() {
3575 let g = Graph::default();
3576 assert!(g.advise);
3577 assert!(g.graft_runner_up, "graft is on by default");
3578 assert_eq!(g.advisors, 3);
3579 }
3580
3581 #[test]
3582 fn unset_advisors_falls_back_to_the_judge_roster() {
3583 let cfg = Config {
3584 agents: vec![spec("a"), spec("b")],
3585 roles: Roles {
3586 judges: vec!["b".to_owned()],
3587 ..Roles::default()
3588 },
3589 graph: Graph {
3590 advisors: 2,
3591 ..Graph::default()
3592 },
3593 ..Config::default()
3594 };
3595 let advisors = cfg.advisors().expect("advisors resolve");
3596 assert_eq!(advisors.len(), 2);
3597 assert!(
3598 advisors.iter().all(|a| a.id == "b"),
3599 "an unset [roles] advisors must fall back to [roles] judges: {advisors:?}"
3600 );
3601 }
3602
3603 #[test]
3604 fn an_explicit_advisor_roster_wins_over_the_judge_fallback() {
3605 let cfg = Config {
3606 agents: vec![spec("a"), spec("b")],
3607 roles: Roles {
3608 judges: vec!["b".to_owned()],
3609 advisors: vec!["a".to_owned()],
3610 ..Roles::default()
3611 },
3612 graph: Graph {
3613 advisors: 2,
3614 ..Graph::default()
3615 },
3616 ..Config::default()
3617 };
3618 let advisors = cfg.advisors().expect("advisors resolve");
3619 assert!(advisors.iter().all(|a| a.id == "a"));
3620 }
3621
3622 #[test]
3628 fn an_unconfigured_advisor_and_judge_roster_resolve_to_the_same_agents() {
3629 let cfg = Config {
3630 agents: vec![spec("a"), spec("b"), spec("c")],
3631 graph: Graph {
3632 advisors: 3,
3633 judges: 3,
3634 ..Graph::default()
3635 },
3636 ..Config::default()
3637 };
3638 let advisors = cfg.advisors().expect("advisors resolve");
3639 let judges = cfg.resolve_roles().expect("roles resolve").judges;
3640 let advisor_ids: Vec<&str> = advisors.iter().map(|a| a.id.as_str()).collect();
3641 let judge_ids: Vec<&str> = judges.iter().map(|a| a.id.as_str()).collect();
3642 assert_eq!(
3643 advisor_ids, judge_ids,
3644 "an unconfigured advisor roster must be the same seats an unconfigured judge panel gets"
3645 );
3646 }
3647
3648 #[test]
3649 fn an_unresolvable_advisor_seat_is_an_error_naming_the_id() {
3650 let cfg = Config {
3651 agents: vec![spec("a")],
3652 roles: Roles {
3653 advisors: vec!["nope".to_owned()],
3654 ..Roles::default()
3655 },
3656 graph: Graph {
3657 advisors: 1,
3658 ..Graph::default()
3659 },
3660 ..Config::default()
3661 };
3662 let err = cfg.advisors().expect_err("`nope` is not in the roster");
3663 assert!(format!("{err:#}").contains("nope"));
3664 }
3665
3666 #[test]
3667 fn repos_default_to_no_roots_and_a_day_of_trust() {
3668 assert_eq!(Config::default().repos.roots, Vec::<PathBuf>::new());
3669 assert_eq!(Config::default().repos.scan_ttl, 86_400);
3670 assert_eq!(Config::default().repos.fetch_interval, 600);
3671 assert!(!Config::default().repos.auto_clone);
3672 assert!(Config::default().repos.clone_command.is_none());
3673 }
3674
3675 #[test]
3676 fn a_config_file_with_no_repos_table_still_loads() {
3677 let dir = tempfile::tempdir().unwrap();
3678 let path = dir.path().join("magi.toml");
3679 std::fs::write(&path, "[graph]\ncandidates = 2\n").unwrap();
3680 let cfg = Config::load(&path).expect("must load without [repos]");
3681 assert_eq!(cfg.repos.roots, Vec::<PathBuf>::new());
3682 assert_eq!(cfg.repos.scan_ttl, 86_400);
3683 }
3684
3685 #[test]
3700 fn a_test_build_does_not_read_the_operators_machine_config() {
3701 let repo = tempfile::tempdir().unwrap();
3702 std::fs::write(repo.path().join("magi.toml"), "[graph]\ncandidates = 2\n").unwrap();
3703
3704 let layers = Config::layers(repo.path());
3705 assert_eq!(
3706 layers,
3707 vec![repo.path().join("magi.toml")],
3708 "only the fixture's own file may be a layer"
3709 );
3710 if let Some(real) = dirs::config_dir() {
3711 let machine = real.join("magi").join("config.toml");
3712 assert!(
3713 !layers.contains(&machine),
3714 "the operator's {} must not be a layer in a test build",
3715 machine.display()
3716 );
3717 }
3718 }
3719
3720 #[test]
3721 fn auto_upgrade_config_defaults_and_opt_in() {
3722 let default: Update = toml::from_str("").unwrap();
3723 assert!(!default.auto_restart);
3724 assert_eq!(default.mode, UpdateMode::Notify);
3725 let enabled: Update = toml::from_str("auto_restart = true\ninterval = \"2h\"\n").unwrap();
3726 assert!(enabled.auto_restart);
3727 assert_eq!(enabled.interval.as_deref(), Some("2h"));
3728 assert!(toml::from_str::<Update>("auto_restart = \"yes\"").is_err());
3729 }
3730
3731 #[test]
3732 fn starter_toml_loads_through_teravars() {
3733 let dir = tempfile::tempdir().unwrap();
3734 let path = dir.path().join("magi.toml");
3735 std::fs::write(&path, Config::starter_toml()).unwrap();
3736 let parsed = Config::load(&path).expect("starter config must load");
3737 assert_eq!(parsed.graph.implementers, 3);
3738 assert_eq!(parsed.merge.mode, MergeMode::None);
3739 assert_eq!(parsed.merge.style, MergeStyle::Merge);
3740 assert!(parsed.graph.sessions);
3741 assert!(parsed.graph.github_text_guard);
3742 assert_eq!(parsed.graph.timeout_review, 1200);
3743 assert_eq!(parsed.graph.verify_timeout(), 1200);
3744 assert_eq!(parsed.update.mode, UpdateMode::Notify);
3745 }
3746
3747 #[test]
3748 fn release_defaults_to_actions_and_the_starter_documents_it() {
3749 let dir = tempfile::tempdir().unwrap();
3750 let path = dir.path().join("magi.toml");
3751 std::fs::write(&path, Config::starter_toml()).unwrap();
3752 let r = Config::load(&path).unwrap().release;
3753 assert_eq!(r.mode, ReleaseMode::Actions);
3754 assert!(!r.is_local());
3755 assert!(r.commands.is_empty());
3756 assert_eq!(r.timeout_minutes, 30);
3757 assert!(Config::starter_toml().contains("# mode = \"actions\""));
3758 }
3759
3760 #[test]
3761 fn release_local_parses_and_unknown_keys_are_refused() {
3762 let dir = tempfile::tempdir().unwrap();
3763 let path = dir.path().join("magi.toml");
3764 std::fs::write(
3765 &path,
3766 "[release]\nmode = \"local\"\ncommands = [\"true\", \"echo $MAGI_RELEASE_TAG\"]\ntimeout_minutes = 5\n",
3767 )
3768 .unwrap();
3769 let r = Config::load(&path).unwrap().release;
3770 assert!(r.is_local());
3771 assert_eq!(r.commands.len(), 2);
3772 assert_eq!(r.timeout_minutes, 5);
3773 std::fs::write(&path, "[release]\nmode = \"local\"\nbogus = 1\n").unwrap();
3774 assert!(Config::load(&path).is_err());
3775 std::fs::write(&path, "[release]\nmode = \"gha\"\n").unwrap();
3776 assert!(Config::load(&path).is_err());
3777 }
3778
3779 #[test]
3780 fn pre_gate_defaults_to_empty_and_the_starter_documents_it() {
3781 let dir = tempfile::tempdir().unwrap();
3782 let path = dir.path().join("magi.toml");
3783 std::fs::write(&path, Config::starter_toml()).unwrap();
3784 assert!(Config::load(&path).unwrap().verify.pre_gate.is_empty());
3785 assert!(Config::starter_toml().contains("# pre_gate = []"));
3786 }
3787
3788 #[test]
3789 fn release_version_files_parse_default_empty_and_are_validated() {
3790 let dir = tempfile::tempdir().unwrap();
3791 let path = dir.path().join("magi.toml");
3792 std::fs::write(&path, "").unwrap();
3793 assert!(
3794 Config::load(&path)
3795 .unwrap()
3796 .release
3797 .version_files
3798 .is_empty()
3799 );
3800 std::fs::write(
3801 &path,
3802 "[release]\nversion_files = [\n{ path = \"src-tauri/Cargo.toml\", kind = \"cargo\" },\n{ path = \"package.json\", kind = \"json\" },\n]\n",
3803 )
3804 .unwrap();
3805 let files = Config::load(&path).unwrap().release.version_files;
3806 assert_eq!(files.len(), 2);
3807 assert_eq!(files[1].kind, VersionKind::Json);
3808 for bad in [
3809 "{ path = \"package.json\", kind = \"json\" }",
3810 "{ path = \"../Cargo.toml\", kind = \"cargo\" }",
3811 "{ path = \"Cargo.toml\", kind = \"cargo\", extra = 1 }",
3812 "{ path = \"Cargo.toml\", kind = \"yaml\" }",
3813 ] {
3814 std::fs::write(&path, format!("[release]\nversion_files = [{bad}]\n")).unwrap();
3815 assert!(Config::load(&path).is_err(), "{bad}");
3816 }
3817 assert!(Config::starter_toml().contains("# version_files = ["));
3818 }
3819
3820 #[test]
3821 fn starter_toml_explains_inherited_and_explicit_verify_timeouts() {
3822 let starter = Config::starter_toml();
3823 assert!(starter.contains("When timeout_verify is omitted, E2E and"));
3824 assert!(starter.contains("verification independent if timeout_review changes later"));
3825 assert!(starter.contains("# timeout_verify = 1200"));
3826 }
3827
3828 #[test]
3829 fn starter_toml_documents_chat_personas() {
3830 let starter = Config::starter_toml();
3831 assert!(starter.contains("# [[talk.personas]]"));
3832 assert!(starter.contains("tone only"));
3833 }
3834
3835 #[test]
3836 fn talk_personas_parse_and_are_validated() {
3837 let dir = tempfile::tempdir().unwrap();
3838 let path = dir.path().join("magi.toml");
3839 std::fs::write(
3840 &path,
3841 "[[talk.personas]]\nid = \"rei\"\nname = \"Quiet\"\nprompt = \"Be brief.\"\n\n\
3842 [[talk.personas]]\nid = \"gendo\"\nname = \"Gendo\"\nprompt = \"Be cold.\"\n",
3843 )
3844 .unwrap();
3845 let cfg = Config::load(&path).expect("loads");
3846 assert_eq!(cfg.talk.personas.len(), 2);
3847 let catalog = crate::persona::catalog(&cfg.talk.personas);
3848 let rei = catalog.iter().find(|p| p.id == "rei").unwrap();
3849 assert_eq!(
3850 (rei.name.as_str(), rei.prompt.as_str()),
3851 ("Quiet", "Be brief.")
3852 );
3853 assert_eq!(catalog.last().unwrap().id, "gendo");
3854
3855 for (body, needle) in [
3856 (
3857 "[[talk.personas]]\nid = \"\"\nname = \"n\"\nprompt = \"p\"\n",
3858 "empty `id`",
3859 ),
3860 (
3861 "[[talk.personas]]\nid = \"a\"\nname = \"n\"\nprompt = \" \"\n",
3862 "empty `prompt`",
3863 ),
3864 (
3865 "[[talk.personas]]\nid = \"a\"\nname = \"n\"\nprompt = \"p\"\n\
3866 [[talk.personas]]\nid = \"a\"\nname = \"m\"\nprompt = \"q\"\n",
3867 "more than once",
3868 ),
3869 (
3870 "[[talk.personas]]\nid = \"default\"\nname = \"n\"\nprompt = \"p\"\n",
3871 "cannot be redefined",
3872 ),
3873 ] {
3874 std::fs::write(&path, body).unwrap();
3875 let err = format!("{:#}", Config::load(&path).unwrap_err());
3876 assert!(err.contains(needle), "{needle}: {err}");
3877 }
3878 }
3879
3880 #[test]
3881 fn talk_operator_name_is_trimmed_and_validated() {
3882 let dir = tempfile::tempdir().unwrap();
3883 let path = dir.path().join("magi.toml");
3884 let load = |body: &str| {
3885 std::fs::write(&path, body).unwrap();
3886 Config::load(&path)
3887 };
3888 let ok = load("[talk]\noperator_name = \" Commander \"\n").expect("ok");
3889 assert_eq!(ok.talk.operator_name(), Some("Commander"));
3890 let blank = load("[talk]\noperator_name = \" \"\n").expect("blank");
3891 assert_eq!(blank.talk.operator_name(), None);
3892 assert!(load("[talk]\noperator_name = \"a\\nb\"\n").is_err());
3893 let long = "x".repeat(65);
3894 assert!(load(&format!("[talk]\noperator_name = \"{long}\"\n")).is_err());
3895 }
3896
3897 #[test]
3898 fn talk_persona_icon_parses_and_a_bad_shape_keeps_config_usable() {
3899 let dir = tempfile::tempdir().unwrap();
3900 let load = |body: &str| {
3901 let path = dir.path().join("c.toml");
3902 std::fs::write(&path, body).unwrap();
3903 Config::load(&path)
3904 };
3905 let ok = load(
3906 "[[talk.personas]]\nid = \"rei\"\nicon = \"~/rei.png\"\n\n\
3907 [[talk.personas]]\nid = \"default\"\nicon = \"data:image/png;base64,AAAA\"\n",
3908 )
3909 .unwrap();
3910 let c = crate::persona::catalog(&ok.talk.personas);
3911 assert_eq!(c[0].icon.as_deref(), Some("data:image/png;base64,AAAA"));
3912 assert_eq!(c[2].icon.as_deref(), Some("~/rei.png"));
3913 assert!(c[2].prompt.contains("Rei"), "built-in voice kept");
3914 let oversized = format!(
3915 "data:image/png;base64,{}",
3916 "A".repeat(crate::persona_icon::ICON_MAX_BYTES)
3917 );
3918 for bad in ["", "rei.png", "/a/b.svg", "/a/../b.png", &oversized] {
3919 for (id, fields) in [
3920 ("rei", ""),
3921 ("default", ""),
3922 ("custom", "name = \"Custom\"\nprompt = \"Keep calm\"\n"),
3923 ] {
3924 let body = format!("[[talk.personas]]\nid = \"{id}\"\nicon = \"{bad}\"\n{fields}");
3925 let cfg = load(&body).expect("bad icon must not invalidate config");
3926 let persona = crate::persona::find(&cfg.talk.personas, id).unwrap();
3927 assert_eq!(persona.id, id);
3928 assert!(crate::persona_icon::load(bad).is_err());
3929 }
3930 }
3931 let doc = Config::starter_toml();
3932 assert!(doc.contains("# icon = "));
3933 }
3934
3935 #[test]
3936 fn talk_personas_in_two_layers_are_refused() {
3937 let dir = tempfile::tempdir().unwrap();
3938 let machine = dir.path().join("machine.toml");
3939 let repo = dir.path().join("repo.toml");
3940 let one = "[[talk.personas]]\nid = \"a\"\nname = \"n\"\nprompt = \"p\"\n";
3941 std::fs::write(&machine, one).unwrap();
3942 std::fs::write(&repo, one.replace("\"a\"", "\"b\"")).unwrap();
3943 let err = format!("{:#}", Config::load_layers(&[machine, repo]).unwrap_err());
3944 assert!(err.contains("talk.personas"), "{err}");
3945 }
3946
3947 #[test]
3948 fn starter_toml_documents_role_lists_as_backup_order() {
3949 let starter = Config::starter_toml();
3950 assert!(starter.contains("also an ordered backup list"));
3951 assert!(starter.contains("codex then sonnet are spares"));
3952 }
3953
3954 #[test]
3958 fn a_repository_can_declare_a_linear_history_merge_style() {
3959 let dir = tempfile::tempdir().unwrap();
3960 let path = dir.path().join("magi.toml");
3961 std::fs::write(&path, "[merge]\nmode = \"none\"\nstyle = \"squash\"\n").unwrap();
3962 let parsed = Config::load(&path).expect("config must load");
3963 assert_eq!(parsed.merge.style, MergeStyle::Squash);
3964 }
3965
3966 #[test]
3967 fn later_layers_win_and_vars_render() {
3968 let dir = tempfile::tempdir().unwrap();
3969 let machine = dir.path().join("machine.toml");
3970 let project = dir.path().join("magi.toml");
3971 std::fs::write(
3973 &machine,
3974 "[[agents]]\nid = \"opus\"\nkind = \"claude\"\nmodel = \"opus\"\n\n\
3975 [graph]\ncandidates = 3\nmax_parallel = 8\n",
3976 )
3977 .unwrap();
3978 std::fs::write(
3981 &project,
3982 "[vars]\ncache = \"/shared\"\n\n\
3983 [graph]\ncandidates = 2\n\n\
3984 [verify]\ngate = [\"CARGO_TARGET_DIR={{ vars.cache }}/t cargo test\"]\n",
3985 )
3986 .unwrap();
3987
3988 let cfg = Config::load_layers(&[machine, project]).expect("layered load");
3989 assert_eq!(cfg.agents.len(), 1, "roster comes from the machine layer");
3990 assert_eq!(cfg.graph.implementers, 2, "project layer wins");
3991 assert_eq!(cfg.graph.max_parallel, 8, "machine layer survives");
3992 assert_eq!(
3993 cfg.verify.gate,
3994 ["CARGO_TARGET_DIR=/shared/t cargo test".to_owned()]
3995 );
3996 assert_eq!(cfg.cache_dir(), Some(PathBuf::from("/shared/t")));
3998 }
3999
4000 #[test]
4001 fn talk_defaults_to_an_hour_and_an_unwritten_config_still_gets_it() {
4002 let g = Graph::default();
4006 assert_eq!(g.timeout_talk, 3600);
4007
4008 let dir = tempfile::tempdir().unwrap();
4009 let path = dir.path().join("magi.toml");
4010 std::fs::write(&path, "[graph]\ncandidates = 2\n").unwrap();
4011 let cfg = Config::load(&path).expect("must load without timeout_talk set");
4012 assert_eq!(cfg.graph.timeout_talk, 3600);
4013 }
4014
4015 #[test]
4016 fn an_overridden_talk_timeout_reaches_the_loaded_config() {
4017 let dir = tempfile::tempdir().unwrap();
4018 let path = dir.path().join("magi.toml");
4019 std::fs::write(&path, "[graph]\ntimeout_talk = 120\n").unwrap();
4020 let cfg = Config::load(&path).expect("must load");
4021 assert_eq!(cfg.graph.timeout_talk, 120);
4022 }
4023
4024 #[test]
4025 fn the_disk_defaults_are_the_measurements_made_up_front() {
4026 let cfg = Config::default();
4027 assert_eq!(cfg.disk.min_free_bytes, 8 * 1024 * 1024 * 1024);
4028 assert!(cfg.disk.auto_fold);
4029 assert_eq!(cfg.disk.fold_grace_secs, 6 * 60 * 60);
4030 assert_eq!(cfg.disk.cache_limit_bytes, 10 * 1024 * 1024 * 1024);
4031 }
4032
4033 #[test]
4034 fn an_unset_disk_section_is_the_safe_default() {
4035 let dir = tempfile::tempdir().unwrap();
4036 std::fs::write(dir.path().join("magi.toml"), "[graph]\ncandidates = 1\n").unwrap();
4037 let cfg = Config::load(&dir.path().join("magi.toml")).expect("load");
4038 assert_eq!(cfg.disk, Disk::default());
4039 }
4040
4041 #[test]
4042 fn env_is_available_to_templates_with_a_default() {
4043 let dir = tempfile::tempdir().unwrap();
4044 let path = dir.path().join("magi.toml");
4045 std::fs::write(
4053 &path,
4054 "[verify]\n\
4055 gate = [\"cache={{ env.MAGI_TEST_UNSET_XYZ | default(value='fallback') }}\", \
4056 \"populated={{ env | length > 0 }}\"]\n",
4057 )
4058 .unwrap();
4059 let cfg = Config::load(&path).expect("env lookup must render");
4060 assert_eq!(cfg.verify.gate[0], "cache=fallback");
4061 assert_eq!(cfg.verify.gate[1], "populated=true");
4062 }
4063
4064 #[test]
4065 fn a_broken_template_names_the_file() {
4066 let dir = tempfile::tempdir().unwrap();
4067 let path = dir.path().join("magi.toml");
4068 std::fs::write(&path, "[graph]\nlanguage = \"{{ nope.\"\n").unwrap();
4069 let err = Config::load(&path).expect_err("must not silently ignore");
4070 assert!(err.to_string().contains("teravars"), "{err}");
4071 }
4072
4073 #[test]
4074 fn tera_syntax_in_comments_is_inert() {
4075 let dir = tempfile::tempdir().unwrap();
4079 let path = dir.path().join("magi.toml");
4080 std::fs::write(
4081 &path,
4082 "# a comment may quote templates: `{{ env.NOPE | default(value='x') }}` and `{% if %}`\n\
4083 [graph]\ncandidates = 2\n",
4084 )
4085 .unwrap();
4086 let cfg = Config::load(&path).expect("comments must be inert, not rendered");
4087 assert_eq!(cfg.graph.implementers, 2);
4088 }
4089
4090 #[test]
4091 fn agent_turn_cap_round_trips_and_never_extends_the_budget() {
4092 use std::time::Duration;
4093
4094 let mut s: AgentSpec =
4095 toml::from_str("id = 'slow'\nkind = 'command'\ncommand = ['true']\n").unwrap();
4096 let budget = Duration::from_millis(1500);
4097 assert_eq!(s.max_turn_secs, None);
4098 assert_eq!(s.turn_timeout(budget), budget);
4099 assert!(!toml::to_string(&s).unwrap().contains("max_turn_secs"));
4100 for (cap, expected) in [
4101 (1, Duration::from_secs(1)),
4102 (2, budget),
4103 (0, Duration::ZERO),
4104 ] {
4105 s.max_turn_secs = Some(cap);
4106 let saved = toml::to_string(&s).unwrap();
4107 let loaded: AgentSpec = toml::from_str(&saved).unwrap();
4108 assert_eq!(loaded.max_turn_secs, Some(cap));
4109 assert_eq!(loaded.turn_timeout(budget), expected);
4110 }
4111 }
4112
4113 #[test]
4114 fn opencode_defaults_to_file_delivery() {
4115 let mut s = spec("oc");
4116 s.kind = AgentKind::Opencode;
4117 assert_eq!(s.delivery(), Delivery::File);
4118 s.prompt_delivery = Some(Delivery::Argv);
4119 assert_eq!(s.delivery(), Delivery::Argv);
4120 }
4121 #[test]
4122 fn the_land_loop_is_on_but_it_cannot_merge_without_being_asked() {
4123 let g = Graph::default();
4128 assert!(
4129 g.land,
4130 "stopping at an open PR left the watching to a human"
4131 );
4132 assert!(
4133 g.land_approval,
4134 "on-by-default land is only defensible while this is also on"
4135 );
4136 assert!(g.land_rounds > 0, "a loop with no budget never terminates");
4137 assert!(
4138 g.hold_contested_merge,
4139 "a contested hand-off must still reach a human when approvals are off"
4140 );
4141 }
4142 #[test]
4143 fn an_array_declared_in_two_layers_is_refused_instead_of_concatenated() {
4144 let dir = tempfile::tempdir().unwrap();
4148 let machine = dir.path().join("machine.toml");
4149 let repo = dir.path().join("magi.toml");
4150 std::fs::write(&machine, "[roles]\nimplementers = [\"a\", \"b\"]\n").unwrap();
4151 std::fs::write(&repo, "[roles]\nimplementers = [\"oc\"]\n").unwrap();
4152
4153 let err = Config::load_layers(&[machine.clone(), repo.clone()])
4154 .expect_err("two layers naming one array must not merge silently");
4155 assert_eq!(
4156 err.downcast_ref::<ConfigFailure>().unwrap().stage,
4157 "config-merge"
4158 );
4159 let err = err.to_string();
4160 assert!(err.contains("roles.implementers"), "{err}");
4161 assert!(err.contains("machine.toml"), "{err}");
4164 assert!(err.contains("magi.toml"), "{err}");
4165 }
4166
4167 #[test]
4168 fn a_scalar_in_one_layer_and_an_array_in_another_still_merges() {
4169 let dir = tempfile::tempdir().unwrap();
4172 let machine = dir.path().join("machine.toml");
4173 let repo = dir.path().join("magi.toml");
4174 std::fs::write(&machine, "[roles]\nchatter = \"opus\"\n").unwrap();
4175 std::fs::write(
4176 &repo,
4177 "[[agents]]\nid = \"oc\"\nkind = \"opencode\"\n\n\
4178 [roles]\nimplementers = [\"oc\"]\n",
4179 )
4180 .unwrap();
4181
4182 let cfg = Config::load_layers(&[machine, repo]).expect("layers merge");
4183 assert_eq!(primary(cfg.roles.chatter.as_ref()), Some("opus"));
4184 assert_eq!(cfg.roles.implementers, ["oc"]);
4185 assert_eq!(cfg.agents.len(), 1, "the roster is not doubled");
4186 }
4187
4188 #[test]
4189 fn two_layers_declaring_verify_gate_run_both_in_priority_order() {
4190 let dir = tempfile::tempdir().unwrap();
4193 let machine = dir.path().join("machine.toml");
4194 let repo = dir.path().join("magi.toml");
4195 std::fs::write(&machine, "[verify]\ngate = [\"editorconfig-checker\"]\n").unwrap();
4196 std::fs::write(&repo, "[verify]\ngate = [\"cargo make check\"]\n").unwrap();
4197
4198 let cfg = Config::load_layers(&[machine, repo]).expect("appendable arrays must merge");
4199 assert_eq!(
4200 cfg.verify.gate,
4201 [
4202 "editorconfig-checker".to_owned(),
4203 "cargo make check".to_owned()
4204 ],
4205 "low-priority (machine) command first, high-priority (repo) command after"
4206 );
4207 }
4208
4209 fn load_one(body: &str) -> Result<Config> {
4210 let dir = tempfile::tempdir().unwrap();
4211 let path = dir.path().join("magi.toml");
4212 std::fs::write(&path, body).unwrap();
4213 Config::load_layers(&[path])
4214 }
4215
4216 #[test]
4217 fn pre_clean_config_is_strict_and_single_layer() {
4218 assert!(Config::default().worktree.pre_clean.is_empty());
4219 let good = load_one("[worktree]\npre_clean = [{run = 'cleanup', timeout_secs = 60}]\n");
4220 assert_eq!(good.unwrap().worktree.pre_clean[0].timeout_secs, Some(60));
4221 for bad in [
4222 "{}",
4223 "{run = ''}",
4224 "{run = ' ', timeout_secs = 2}",
4225 "{run = 'x', timeout_secs = 0}",
4226 "{run = 'x', timeout_secs = -1}",
4227 "{copy = 'cache'}",
4228 "{run = 'x', optional = true}",
4229 "'x'",
4230 ] {
4231 assert!(
4232 load_one(&format!("[worktree]\npre_clean = [{bad}]\n")).is_err(),
4233 "{bad}"
4234 );
4235 }
4236 let dir = tempfile::tempdir().unwrap();
4237 let a = dir.path().join("a.toml");
4238 let b = dir.path().join("b.toml");
4239 for path in [&a, &b] {
4240 std::fs::write(path, "[worktree]\npre_clean = [{run = 'cleanup'}]\n").unwrap();
4241 }
4242 assert!(
4243 Config::load_layers(&[a, b])
4244 .unwrap_err()
4245 .to_string()
4246 .contains("worktree.pre_clean")
4247 );
4248 }
4249
4250 #[test]
4251 fn worktree_setup_defaults_to_empty_and_parses_steps() {
4252 assert!(Config::default().worktree.setup.is_empty());
4253 let cfg = load_one(
4254 "[worktree]\nsetup = [\n { copy = \".env.example -> .env\" },\n \
4255 { copy = \"x\", optional = true },\n { run = \"true\", timeout_secs = 5 },\n]\n",
4256 )
4257 .unwrap();
4258 assert_eq!(cfg.worktree.setup.len(), 3);
4259 assert!(cfg.worktree.setup[1].optional);
4260 assert_eq!(cfg.worktree.setup[2].timeout_secs, Some(5));
4261 }
4262
4263 #[test]
4264 fn worktree_setup_rejects_malformed_steps() {
4265 for bad in [
4266 "{ copy = \"a\", run = \"b\" }",
4267 "{ optional = true }",
4268 "{ copy = \"a -> ../b\" }",
4269 "{ copy = \"a -> /abs\" }",
4270 "{ copy = \"a -> .git/config\" }",
4271 "{ run = \"b\", optional = true }",
4272 "{ copy = \"a\", timeout_secs = 3 }",
4273 "{ run = \"b\", bogus = 1 }",
4274 ] {
4275 let body = format!("[worktree]\nsetup = [{bad}]\n");
4276 assert!(load_one(&body).is_err(), "{bad}");
4277 }
4278 }
4279
4280 #[test]
4281 fn worktree_setup_in_two_layers_is_refused() {
4282 let dir = tempfile::tempdir().unwrap();
4283 let machine = dir.path().join("machine.toml");
4284 let repo = dir.path().join("magi.toml");
4285 std::fs::write(&machine, "[worktree]\nsetup = [{ run = \"a\" }]\n").unwrap();
4286 std::fs::write(&repo, "[worktree]\nsetup = [{ run = \"b\" }]\n").unwrap();
4287 assert!(Config::load_layers(&[machine, repo]).is_err());
4288 }
4289
4290 #[test]
4291 fn starter_toml_documents_worktree_setup() {
4292 let starter = Config::starter_toml();
4293 assert!(starter.contains("# [worktree]") && starter.contains("setup = ["));
4294 let body = starter.replace("# [worktree]", "[worktree]");
4296 let mut out = String::new();
4297 let mut live = false;
4298 for line in body.lines() {
4299 if line == "[worktree]" {
4300 live = true;
4301 } else if live && !line.starts_with("# ") {
4302 live = false;
4303 }
4304 out.push_str(&if live {
4305 line.replacen("# ", "", 1)
4306 } else {
4307 line.to_owned()
4308 });
4309 out.push('\n');
4310 }
4311 let cfg = load_one(&out).expect("uncommented example loads");
4312 assert_eq!(cfg.worktree.setup.len(), 3);
4313 }
4314
4315 #[test]
4316 fn two_layers_declaring_verify_e2e_run_both_in_priority_order() {
4317 let dir = tempfile::tempdir().unwrap();
4318 let machine = dir.path().join("machine.toml");
4319 let repo = dir.path().join("magi.toml");
4320 std::fs::write(&machine, "[verify]\ne2e = [\"shared-smoke-test\"]\n").unwrap();
4321 std::fs::write(&repo, "[verify]\ne2e = [\"cargo test\"]\n").unwrap();
4322
4323 let cfg = Config::load_layers(&[machine, repo]).expect("appendable arrays must merge");
4324 assert_eq!(
4325 cfg.verify.e2e,
4326 ["shared-smoke-test".to_owned(), "cargo test".to_owned()]
4327 );
4328 }
4329
4330 #[test]
4331 fn two_layers_declaring_repos_roots_are_both_scanned() {
4332 let dir = tempfile::tempdir().unwrap();
4333 let machine = dir.path().join("machine.toml");
4334 let repo = dir.path().join("magi.toml");
4335 std::fs::write(&machine, "[repos]\nroots = [\"/machine/root\"]\n").unwrap();
4336 std::fs::write(&repo, "[repos]\nroots = [\"/repo/root\"]\n").unwrap();
4337
4338 let cfg = Config::load_layers(&[machine, repo]).expect("appendable arrays must merge");
4339 assert_eq!(
4340 cfg.repos.roots,
4341 [PathBuf::from("/machine/root"), PathBuf::from("/repo/root")]
4342 );
4343 }
4344
4345 #[test]
4346 fn duplicate_gate_commands_across_layers_both_run() {
4347 let dir = tempfile::tempdir().unwrap();
4350 let machine = dir.path().join("machine.toml");
4351 let repo = dir.path().join("magi.toml");
4352 std::fs::write(&machine, "[verify]\ngate = [\"same-command\"]\n").unwrap();
4353 std::fs::write(&repo, "[verify]\ngate = [\"same-command\"]\n").unwrap();
4354
4355 let cfg = Config::load_layers(&[machine, repo]).expect("appendable arrays must merge");
4356 assert_eq!(
4357 cfg.verify.gate,
4358 ["same-command".to_owned(), "same-command".to_owned()]
4359 );
4360 }
4361
4362 #[test]
4363 fn notify_command_is_still_refused_across_two_layers() {
4364 let dir = tempfile::tempdir().unwrap();
4366 let machine = dir.path().join("machine.toml");
4367 let repo = dir.path().join("magi.toml");
4368 std::fs::write(&machine, "[notify]\ncommand = [\"ntfy\", \"publish\"]\n").unwrap();
4369 std::fs::write(&repo, "[notify]\ncommand = [\"curl\", \"-X\"]\n").unwrap();
4370
4371 let err = Config::load_layers(&[machine.clone(), repo.clone()])
4372 .expect_err("an argv split across layers must not concatenate");
4373 assert_eq!(
4374 err.downcast_ref::<ConfigFailure>().unwrap().stage,
4375 "config-merge"
4376 );
4377 let err = err.to_string();
4378 assert!(err.contains("notify.command"), "{err}");
4379 assert!(err.contains("machine.toml"), "{err}");
4380 assert!(err.contains("magi.toml"), "{err}");
4381 }
4382
4383 #[test]
4384 fn one_layer_declaring_verify_gate_runs_unchanged() {
4385 let dir = tempfile::tempdir().unwrap();
4388 let path = dir.path().join("magi.toml");
4389 std::fs::write(&path, "[verify]\ngate = [\"cargo make check\"]\n").unwrap();
4390
4391 let cfg = Config::load(&path).expect("single layer must still load");
4392 assert_eq!(cfg.verify.gate, ["cargo make check".to_owned()]);
4393 }
4394
4395 #[test]
4396 fn layered_parse_failures_name_the_failing_input() {
4397 let dir = tempfile::tempdir().unwrap();
4398 let a = dir.path().join("a.toml");
4399 let b = dir.path().join("b.toml");
4400 std::fs::write(&a, "[graph").unwrap();
4401 std::fs::write(&b, "[verify").unwrap();
4402 let paths = [a.clone(), b.clone()];
4403 let first = Config::load_layers(&paths).unwrap_err();
4404 let first_cause = first.downcast_ref::<ConfigFailure>().unwrap();
4405 assert_eq!(first_cause.stage, "config-parse");
4406 assert_eq!(first_cause.target, serde_json::to_string(&[&a]).unwrap());
4407 std::fs::write(&a, "").unwrap();
4408 let second = Config::load_layers(&paths).unwrap_err();
4409 let second_cause = second.downcast_ref::<ConfigFailure>().unwrap();
4410 assert_eq!(second_cause.stage, "config-parse");
4411 assert_eq!(second_cause.target, serde_json::to_string(&[&b]).unwrap());
4412 assert_ne!(first_cause.target, second_cause.target);
4413 }
4414
4415 #[test]
4416 fn describe_composed_names_the_contributing_layers_only_when_there_are_two() {
4417 let dir = tempfile::tempdir().unwrap();
4418 let machine = dir.path().join("machine.toml");
4419 let repo = dir.path().join("magi.toml");
4420 std::fs::write(&machine, "[verify]\ngate = [\"editorconfig-checker\"]\n").unwrap();
4421 std::fs::write(&repo, "[verify]\ngate = [\"cargo make check\"]\n").unwrap();
4422 let paths = vec![machine.clone(), repo.clone()];
4423
4424 let cfg = Config::load_layers(&paths).expect("appendable arrays must merge");
4425 let described =
4426 Config::describe_composed(&paths, &cfg.verify.gate, "verify.gate", "(none)");
4427 assert!(described.contains("editorconfig-checker && cargo make check"));
4428 assert!(
4429 described.contains(&machine.display().to_string()),
4430 "{described}"
4431 );
4432 assert!(
4433 described.contains(&repo.display().to_string()),
4434 "{described}"
4435 );
4436
4437 let single = vec![repo.clone()];
4439 let solo_cfg = Config::load_layers(&single).expect("single layer loads");
4440 let solo_described =
4441 Config::describe_composed(&single, &solo_cfg.verify.gate, "verify.gate", "(none)");
4442 assert_eq!(solo_described, "cargo make check");
4443 }
4444
4445 mod remote_layers {
4446 use super::*;
4447
4448 fn git(dir: &Path, args: &[&str]) {
4449 use crate::proc::Quiet as _;
4450 let out = std::process::Command::new("git")
4451 .args(args)
4452 .quiet()
4453 .current_dir(dir)
4454 .output()
4455 .unwrap();
4456 assert!(out.status.success(), "git {args:?}: {out:?}");
4457 }
4458
4459 fn fixture(remote: &str, disk: &str) -> (tempfile::TempDir, PathBuf) {
4462 let tmp = tempfile::tempdir().unwrap();
4463 let bare = tmp.path().join("o.git");
4464 git(tmp.path(), &["init", "--bare", "-b", "trunk", "o.git"]);
4465 let repo = tmp.path().join("repo");
4466 std::fs::create_dir_all(&repo).unwrap();
4467 git(&repo, &["init", "-b", "trunk"]);
4468 git(&repo, &["config", "user.name", "t"]);
4469 git(&repo, &["config", "user.email", "t@example.com"]);
4470 std::fs::write(repo.join("magi.toml"), remote).unwrap();
4471 git(&repo, &["add", "-A"]);
4472 git(&repo, &["commit", "-m", "x"]);
4473 git(&repo, &["remote", "add", "origin", &bare.to_string_lossy()]);
4474 git(&repo, &["push", "origin", "trunk"]);
4475 git(&repo, &["fetch", "origin"]);
4476 git(&repo, &["remote", "set-head", "origin", "trunk"]);
4477 std::fs::write(repo.join("magi.toml"), disk).unwrap();
4478 (tmp, repo)
4479 }
4480
4481 #[tokio::test]
4482 async fn branch_owner_holds_only_add_literal_true_values() {
4483 for (text, expected) in [
4484 ("[graph]\nland_approval = true\n", true),
4485 ("[graph]\nland_approval = false\n", false),
4486 ("[graph]\nland = true\n", false),
4487 ("[graph\n", false),
4488 ("[graph]\nland_approval = \"yes\"\n", false),
4489 ("[graph]\nland_approval = 1\n", false),
4490 ] {
4491 let (_tmp, repo) = fixture(text, "[graph]\nland_approval = false\n");
4492 let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
4493 let (holds, _) = branch_owner_holds(&repo, &head).await;
4494 assert_eq!(
4495 holds.contains(&(OwnerHold::LandApproval, "magi.toml".into())),
4496 expected
4497 );
4498 assert!(
4499 !holds
4500 .iter()
4501 .any(|(h, _)| *h == OwnerHold::HoldContestedMerge)
4502 );
4503 for base in [false, true] {
4504 let mut cfg = Config::default();
4505 cfg.graph.land_approval = base;
4506 let mut state = crate::run::RunState::new(
4507 repo.clone(),
4508 "trunk".into(),
4509 head.clone(),
4510 "review".into(),
4511 cfg,
4512 );
4513 state.observe_branch_owner_holds(&head).await;
4514 assert!(
4515 state.branch_owner_holds.is_empty(),
4516 "competition candidates are excluded"
4517 );
4518 state.reviewed_commits = Some(Vec::new());
4519 state.observe_branch_owner_holds(&head).await;
4520 assert_eq!(state.owner_hold(OwnerHold::LandApproval), base || expected);
4521 }
4522 }
4523 }
4524
4525 #[tokio::test]
4526 async fn branch_owner_holds_missing_and_unreadable_preserve_base() {
4527 let (_tmp, repo) = fixture(
4528 "[graph]\nland_approval = true\n",
4529 "[graph]\nland_approval = true\n",
4530 );
4531 git(&repo, &["rm", "magi.toml"]);
4532 std::fs::create_dir(repo.join(".magi")).unwrap();
4533 std::fs::write(
4534 repo.join(".magi/config.toml"),
4535 "[graph]\nhold_contested_merge = true\n",
4536 )
4537 .unwrap();
4538 git(&repo, &["add", "."]);
4539 git(&repo, &["commit", "-m", "nested hold"]);
4540 let head = crate::git::rev_parse(&repo, "HEAD").await.unwrap();
4541 let (holds, _) = branch_owner_holds(&repo, &head).await;
4542 assert_eq!(
4543 holds,
4544 [(OwnerHold::HoldContestedMerge, ".magi/config.toml".into())]
4545 );
4546 let (holds, diagnostics) =
4547 branch_owner_holds(&repo, "0000000000000000000000000000000000000000").await;
4548 assert!(holds.is_empty());
4549 assert!(!diagnostics.is_empty());
4550 let (holds, diagnostics) = branch_owner_holds(&repo, "").await;
4551 assert!(holds.is_empty());
4552 assert!(!diagnostics.is_empty());
4553 for base in [false, true] {
4554 let mut cfg = Config::default();
4555 cfg.graph.land_approval = base;
4556 let mut state = crate::run::RunState::new(
4557 repo.clone(),
4558 "trunk".into(),
4559 head.clone(),
4560 "review".into(),
4561 cfg,
4562 );
4563 state.reviewed_commits = Some(Vec::new());
4564 state.observe_branch_owner_holds(&head).await;
4565 assert_eq!(state.owner_hold(OwnerHold::LandApproval), base);
4566 state
4567 .observe_branch_owner_holds("0000000000000000000000000000000000000000")
4568 .await;
4569 assert_eq!(state.owner_hold(OwnerHold::LandApproval), base);
4570 }
4571 }
4572
4573 #[test]
4574 fn reads_the_remote_blob_not_the_working_tree() {
4575 let (_t, repo) = fixture("[graph]\ncandidates = 2\n", "[graph]\ncandidates = 5\n");
4576 let (cfg, _) = Config::discover(&repo, None).unwrap();
4577 assert_eq!(cfg.graph.implementers, 2);
4578 }
4579
4580 #[test]
4581 fn detached_head_still_reads_the_remote() {
4582 let (_t, repo) = fixture("[graph]\ncandidates = 2\n", "[graph]\ncandidates = 5\n");
4583 git(&repo, &["checkout", "--detach"]);
4584 let (cfg, _) = Config::discover(&repo, None).unwrap();
4585 assert_eq!(cfg.graph.implementers, 2);
4586 }
4587
4588 #[test]
4589 fn a_missing_ref_is_an_error_not_a_fallback() {
4590 let (_t, repo) = fixture("[graph]\ncandidates = 2\n", "[graph]\ncandidates = 5\n");
4591 git(&repo, &["update-ref", "-d", "refs/remotes/origin/trunk"]);
4592 let err = format!("{:#}", Config::discover(&repo, None).unwrap_err());
4593 assert!(err.contains("origin"), "{err}");
4594 }
4595
4596 #[test]
4597 fn merge_base_in_the_checkout_locates_the_ref() {
4598 let (_t, repo) = fixture("[graph]\ncandidates = 2\n", "[merge]\nbase = \"nope\"\n");
4599 assert!(Config::discover(&repo, None).is_err());
4600 }
4601
4602 #[test]
4603 fn the_magi_dir_layer_is_read_too() {
4604 let (_t, repo) = fixture("[graph]\ncandidates = 2\n", "");
4605 std::fs::write(repo.join("magi.toml"), "[graph]\ncandidates = 2\n").unwrap();
4606 std::fs::create_dir_all(repo.join(".magi")).unwrap();
4607 std::fs::write(repo.join(".magi/config.toml"), "[graph]\njudges = 3\n").unwrap();
4608 git(&repo, &["add", "-A"]);
4609 git(&repo, &["commit", "-m", "y"]);
4610 git(&repo, &["push", "origin", "trunk"]);
4611 git(&repo, &["fetch", "origin"]);
4612 let (cfg, layers) = Config::discover(&repo, None).unwrap();
4613 assert_eq!((cfg.graph.implementers, cfg.graph.judges), (2, 3));
4614 assert_eq!(layers.len(), 2);
4615 }
4616
4617 #[test]
4618 fn an_include_in_a_repository_layer_resolves_against_the_same_commit() {
4619 let (_t, repo) = fixture("include = [\"gate.toml\"]\n", "");
4620 std::fs::write(repo.join("magi.toml"), "include = [\"gate.toml\"]\n").unwrap();
4621 std::fs::write(repo.join("gate.toml"), "[graph]\ncandidates = 2\n").unwrap();
4622 git(&repo, &["add", "-A"]);
4623 git(&repo, &["commit", "-m", "inc"]);
4624 git(&repo, &["push", "origin", "trunk"]);
4625 git(&repo, &["fetch", "origin"]);
4626 std::fs::write(repo.join("gate.toml"), "[graph]\ncandidates = 9\n").unwrap();
4628 let (cfg, _) = Config::discover(&repo, None).unwrap();
4629 assert_eq!(cfg.graph.implementers, 2);
4630 }
4631
4632 #[test]
4633 fn a_machine_layer_base_is_rendered_before_locating_the_ref() {
4634 let (t, repo) = fixture("[graph]\ncandidates = 2\n", "[merge]\nbase = \"nope\"\n");
4635 let m = t.path().join("machine.toml");
4636 std::fs::write(
4637 &m,
4638 "[merge]\nbase = \"{{ env.MAGI_TEST_NO_SUCH | default(value='trunk') }}\"\n",
4639 )
4640 .unwrap();
4641 let (remote, base) = {
4642 let probe = probe_merge(&m, &repo).unwrap();
4643 (probe.remote, probe.base)
4644 };
4645 assert_eq!((remote, base), (None, Some("trunk".to_owned())));
4646 }
4647
4648 #[test]
4649 fn a_machine_layer_base_sees_the_checkouts_repo_name() {
4650 let (t, repo) = fixture("[graph]\ncandidates = 2\n", "");
4651 let m = t.path().join("machine.toml");
4652 std::fs::write(&m, "[merge]\nbase = \"{{ repo_name }}\"\n").unwrap();
4653 let probe = probe_merge(&m, &repo).unwrap();
4654 assert_eq!(probe.base.as_deref(), Some("repo"));
4655 }
4656
4657 #[test]
4658 fn every_include_form_is_recognised() {
4659 assert!(declares_include("include = [\"a.toml\"]\n"));
4660 assert!(declares_include("\"include\" = [\"a.toml\"]\n"));
4661 assert!(declares_include("teravars = { include = [\"a.toml\"] }\n"));
4662 assert!(declares_include("[teravars]\ninclude = [\"a.toml\"]\n"));
4663 assert!(!declares_include("[graph]\ncandidates = 2\n"));
4664 }
4665
4666 #[test]
4667 fn an_explicit_config_is_read_as_named() {
4668 let (t, repo) = fixture("[graph]\ncandidates = 2\n", "");
4669 let own = t.path().join("own.toml");
4670 std::fs::write(&own, "[graph]\ncandidates = 4\n").unwrap();
4671 let (cfg, _) = Config::discover(&repo, Some(&own)).unwrap();
4672 assert_eq!(cfg.graph.implementers, 4);
4673 }
4674
4675 #[test]
4676 fn discover_fetched_fails_when_the_fetch_does() {
4677 let (t, repo) = fixture("[graph]\ncandidates = 2\n", "");
4678 std::fs::remove_dir_all(t.path().join("o.git")).unwrap();
4679 let rt = tokio::runtime::Builder::new_current_thread()
4680 .enable_all()
4681 .build()
4682 .unwrap();
4683 let err = rt
4684 .block_on(Config::discover_fetched(&repo, None))
4685 .unwrap_err();
4686 assert!(format!("{err:#}").contains("fetch"), "{err:#}");
4687 }
4688
4689 #[test]
4690 fn fetch_and_remote_parse_failures_have_distinct_verified_causes() {
4691 let (tmp, repo) = fixture("[graph\ncandidates = 2\n", "");
4692 let remote = tmp.path().join("o.git");
4693 let offline = tmp.path().join("offline.git");
4694 std::fs::rename(&remote, &offline).unwrap();
4695 let rt = tokio::runtime::Builder::new_current_thread()
4696 .enable_all()
4697 .build()
4698 .unwrap();
4699 let fetch = rt
4700 .block_on(Config::discover_fetched(&repo, None))
4701 .unwrap_err();
4702 let fetch_cause = fetch.downcast_ref::<ConfigFailure>().unwrap();
4703 assert_eq!(fetch_cause.stage, "config-fetch");
4704 assert_eq!(fetch_cause.target, "origin/trunk");
4705
4706 std::fs::rename(&offline, &remote).unwrap();
4707 let parse = rt
4708 .block_on(Config::discover_fetched(&repo, None))
4709 .unwrap_err();
4710 let parse_cause = parse.downcast_ref::<ConfigFailure>().unwrap();
4711 assert_eq!(parse_cause.stage, "config-parse");
4712 assert!(parse_cause.target.contains("magi.toml"));
4713 assert!(
4714 !parse_cause.target.contains("/magi/config/"),
4715 "cache commit paths are incidental"
4716 );
4717 assert_ne!(fetch_cause.stage, parse_cause.stage);
4718 }
4719
4720 #[test]
4721 fn discover_fetched_survives_a_fetch_that_leaves_no_origin_head() {
4722 let (_t, repo) = fixture("[graph]\ncandidates = 2\n", "");
4725 git(&repo, &["remote", "set-head", "origin", "-d"]);
4726 git(&repo, &["update-ref", "-d", "refs/remotes/origin/trunk"]);
4727 git(
4728 &repo,
4729 &["config", "remote.origin.followRemoteHEAD", "never"],
4730 );
4731 let rt = tokio::runtime::Builder::new_current_thread()
4732 .enable_all()
4733 .build()
4734 .unwrap();
4735 let (cfg, _) = rt.block_on(Config::discover_fetched(&repo, None)).unwrap();
4736 assert_eq!(cfg.graph.implementers, 2);
4737 }
4738
4739 #[test]
4740 fn a_non_git_directory_reads_its_files() {
4741 let dir = tempfile::tempdir().unwrap();
4742 std::fs::write(dir.path().join("magi.toml"), "[graph]\ncandidates = 4\n").unwrap();
4743 let (cfg, _) = Config::discover(dir.path(), None).unwrap();
4744 assert_eq!(cfg.graph.implementers, 4);
4745 }
4746 }
4747
4748 #[test]
4749 fn github_language_defaults_to_english_and_accepts_japanese() {
4750 let default: Graph = toml::from_str("").unwrap();
4751 assert_eq!(default.github_language, "en");
4752 assert!(default.github_english() && default.language_gate());
4753 let ja: Graph = toml::from_str("github_language = \"ja\"").unwrap();
4754 assert!(!ja.github_english() && !ja.language_gate());
4755 let only_ops: Graph = toml::from_str("language = \"ja\"").unwrap();
4757 assert!(only_ops.language_gate());
4758 let off: Graph = toml::from_str("github_text_guard = false").unwrap();
4759 assert!(!off.language_gate() && off.github_english());
4760 assert!(Config::starter_toml().contains("github_language = \"en\""));
4761 }
4762}