@team-agent/installer 0.5.127 → 0.5.128

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (145) hide show
  1. package/Cargo.lock +1 -1
  2. package/Cargo.toml +1 -1
  3. package/README.md +11 -0
  4. package/crates/team-agent/src/cli/adapters.rs +3 -13
  5. package/crates/team-agent/src/cli/arguments.rs +4 -0
  6. package/crates/team-agent/src/cli/diagnose.rs +68 -22
  7. package/crates/team-agent/src/cli/emit.rs +58 -26
  8. package/crates/team-agent/src/cli/intent/runtime.rs +32 -5
  9. package/crates/team-agent/src/cli/intent/runtime_tests.rs +102 -11
  10. package/crates/team-agent/src/cli/intent/tests.rs +10 -12
  11. package/crates/team-agent/src/cli/intent.rs +1 -1
  12. package/crates/team-agent/src/cli/mod.rs +25 -8
  13. package/crates/team-agent/src/cli/models.rs +764 -7
  14. package/crates/team-agent/src/cli/schedule.rs +175 -0
  15. package/crates/team-agent/src/cli/send/persist.rs +0 -36
  16. package/crates/team-agent/src/cli/send/presentation.rs +1 -1
  17. package/crates/team-agent/src/cli/send.rs +108 -110
  18. package/crates/team-agent/src/cli/spec.rs +6 -0
  19. package/crates/team-agent/src/cli/status_port/brief.rs +5 -67
  20. package/crates/team-agent/src/cli/tests/leader_watch.rs +12 -62
  21. package/crates/team-agent/src/cli/tests/mod.rs +1 -1
  22. package/crates/team-agent/src/cli/tests/named_address.rs +11 -10
  23. package/crates/team-agent/src/cli/tests/run_delegation.rs +9 -6
  24. package/crates/team-agent/src/cli/tests/status_send.rs +68 -271
  25. package/crates/team-agent/src/compiler/tests.rs +3 -18
  26. package/crates/team-agent/src/compiler.rs +205 -6
  27. package/crates/team-agent/src/contract_runtime/backend.rs +145 -11
  28. package/crates/team-agent/src/contract_runtime/commands.rs +7 -7
  29. package/crates/team-agent/src/contract_runtime/config.rs +26 -16
  30. package/crates/team-agent/src/contract_runtime/config_tests.rs +24 -4
  31. package/crates/team-agent/src/contract_runtime/discovery.rs +12 -1
  32. package/crates/team-agent/src/contract_runtime/fork.rs +3 -10
  33. package/crates/team-agent/src/contract_runtime/framework.rs +28 -11
  34. package/crates/team-agent/src/contract_runtime/mcp.rs +19 -24
  35. package/crates/team-agent/src/contract_runtime/prompt.rs +2 -2
  36. package/crates/team-agent/src/contract_runtime/registry.rs +56 -92
  37. package/crates/team-agent/src/coordinator/steps/abnormal.rs +11 -11
  38. package/crates/team-agent/src/coordinator/tests/api_error_recovery.rs +16 -54
  39. package/crates/team-agent/src/coordinator/tests/health_sync.rs +42 -0
  40. package/crates/team-agent/src/coordinator/tick.rs +1 -89
  41. package/crates/team-agent/src/db/message_store.rs +7 -65
  42. package/crates/team-agent/src/direct_delivery.rs +368 -0
  43. package/crates/team-agent/src/inbox_store.rs +169 -0
  44. package/crates/team-agent/src/leader/registry.rs +5 -0
  45. package/crates/team-agent/src/leader/start.rs +2 -1
  46. package/crates/team-agent/src/leader/tests/lease_api.rs +2 -2
  47. package/crates/team-agent/src/leader/tests/prompt_contract.rs +1 -0
  48. package/crates/team-agent/src/lib.rs +2 -0
  49. package/crates/team-agent/src/lifecycle/launch/add_agent.rs +33 -0
  50. package/crates/team-agent/src/lifecycle/launch/add_agent_state.rs +206 -1
  51. package/crates/team-agent/src/lifecycle/launch/clone_agent.rs +28 -2
  52. package/crates/team-agent/src/lifecycle/launch/fork_agent.rs +38 -13
  53. package/crates/team-agent/src/lifecycle/launch/fork_entry.rs +87 -6
  54. package/crates/team-agent/src/lifecycle/launch/mcp_config.rs +9 -1
  55. package/crates/team-agent/src/lifecycle/launch/pi_mcp.rs +351 -81
  56. package/crates/team-agent/src/lifecycle/launch/pi_mcp_extension.js +3 -4
  57. package/crates/team-agent/src/lifecycle/launch/quick_start.rs +24 -0
  58. package/crates/team-agent/src/lifecycle/launch/spawn.rs +36 -13
  59. package/crates/team-agent/src/lifecycle/launch.rs +24 -1
  60. package/crates/team-agent/src/lifecycle/profile_launch.rs +321 -11
  61. package/crates/team-agent/src/lifecycle/restart/agent.rs +1 -0
  62. package/crates/team-agent/src/lifecycle/restart/avatar.rs +1798 -0
  63. package/crates/team-agent/src/lifecycle/restart/claude_fork.rs +163 -0
  64. package/crates/team-agent/src/lifecycle/restart/common.rs +345 -35
  65. package/crates/team-agent/src/lifecycle/restart/selection.rs +5 -5
  66. package/crates/team-agent/src/lifecycle/restart.rs +4 -0
  67. package/crates/team-agent/src/lifecycle/role_config.rs +39 -14
  68. package/crates/team-agent/src/lifecycle/tests/claude_compatible_config_red.rs +325 -0
  69. package/crates/team-agent/src/lifecycle/tests/claude_profile_launch_red.rs +320 -8
  70. package/crates/team-agent/src/lifecycle/tests/cli_argv_routing_red.rs +236 -13
  71. package/crates/team-agent/src/lifecycle/tests/clone_fork_copilot_perms_red.rs +378 -4
  72. package/crates/team-agent/src/lifecycle/tests/communication_mode_runtime_contract_red.rs +5 -4
  73. package/crates/team-agent/src/lifecycle/tests/copilot_provider_red.rs +7 -11
  74. package/crates/team-agent/src/lifecycle/tests/core.rs +47 -18
  75. package/crates/team-agent/src/lifecycle/tests/fixtures/pi_native_mcp_host.mjs +2 -1
  76. package/crates/team-agent/src/lifecycle/tests/grok_require_explicit_model_red.rs +14 -14
  77. package/crates/team-agent/src/lifecycle/tests/harvest2_a_batch_red.rs +60 -20
  78. package/crates/team-agent/src/lifecycle/tests/launch_spawn.rs +28 -26
  79. package/crates/team-agent/src/lifecycle/tests/mcp_tool_name_format_red.rs +6 -6
  80. package/crates/team-agent/src/lifecycle/tests/pi_catalog_red.rs +18 -6
  81. package/crates/team-agent/src/lifecycle/tests/pi_command_red.rs +70 -52
  82. package/crates/team-agent/src/lifecycle/tests/pi_compiler_red.rs +210 -0
  83. package/crates/team-agent/src/lifecycle/tests/pi_dual_entry_red.rs +157 -4
  84. package/crates/team-agent/src/lifecycle/tests/pi_executable_mcp_red.rs +526 -10
  85. package/crates/team-agent/src/lifecycle/tests/pi_fork_session_inheritance_red.rs +1419 -0
  86. package/crates/team-agent/src/lifecycle/tests/pi_lifecycle_doctor_red.rs +68 -1
  87. package/crates/team-agent/src/lifecycle/tests/pi_native_mcp_capability_red.rs +34 -12
  88. package/crates/team-agent/src/lifecycle/tests/pi_session_delivery_red.rs +94 -2
  89. package/crates/team-agent/src/lifecycle/tests/quick_start_worker_readiness_red.rs +10 -11
  90. package/crates/team-agent/src/lifecycle/tests/status_credential_redaction_contract.rs +2 -2
  91. package/crates/team-agent/src/lifecycle/tests/swallow_batch4_semantics_red.rs +254 -2
  92. package/crates/team-agent/src/lifecycle/tests/upgrade_compat_0211_red.rs +4 -4
  93. package/crates/team-agent/src/lifecycle/tests/verify_rs031_window_consistency_red.rs +5 -6
  94. package/crates/team-agent/src/lifecycle/tests/worker_spawn_env_red.rs +16 -7
  95. package/crates/team-agent/src/lifecycle/tests.rs +3 -0
  96. package/crates/team-agent/src/lifecycle/types.rs +18 -2
  97. package/crates/team-agent/src/lifecycle/worker_command_context.rs +43 -50
  98. package/crates/team-agent/src/mcp_server/readiness.rs +130 -149
  99. package/crates/team-agent/src/mcp_server/readiness_tests.rs +98 -119
  100. package/crates/team-agent/src/mcp_server/tests/scoped.rs +21 -31
  101. package/crates/team-agent/src/mcp_server/tests/send.rs +72 -107
  102. package/crates/team-agent/src/mcp_server/tests/tools.rs +10 -12
  103. package/crates/team-agent/src/mcp_server/tools.rs +70 -196
  104. package/crates/team-agent/src/messaging/delivery.rs +160 -218
  105. package/crates/team-agent/src/messaging/delivery_consumption_tests.rs +5 -5
  106. package/crates/team-agent/src/messaging/helpers.rs +1 -19
  107. package/crates/team-agent/src/messaging/mod.rs +1 -0
  108. package/crates/team-agent/src/messaging/reminders.rs +316 -0
  109. package/crates/team-agent/src/messaging/scheduler.rs +7 -1
  110. package/crates/team-agent/src/messaging/tests/dup_inject.rs +191 -85
  111. package/crates/team-agent/src/messaging/tests/runtime.rs +4 -110
  112. package/crates/team-agent/src/messaging/tests/spine.rs +40 -24
  113. package/crates/team-agent/src/messaging/types.rs +1 -0
  114. package/crates/team-agent/src/provider/adapter.rs +303 -51
  115. package/crates/team-agent/src/provider/adapters/claude.rs +78 -0
  116. package/crates/team-agent/src/provider/adapters/claude_fork.rs +131 -0
  117. package/crates/team-agent/src/provider/adapters/mod.rs +7 -5
  118. package/crates/team-agent/src/provider/adapters/pi.rs +106 -0
  119. package/crates/team-agent/src/provider/classify.rs +1 -66
  120. package/crates/team-agent/src/provider/model_catalog.rs +201 -13
  121. package/crates/team-agent/src/provider/session/capture.rs +106 -6
  122. package/crates/team-agent/src/provider/session/context_fork/claude.rs +123 -0
  123. package/crates/team-agent/src/provider/session/context_fork/outcome.rs +4 -0
  124. package/crates/team-agent/src/provider/session/context_fork.rs +150 -18
  125. package/crates/team-agent/src/provider/session_scan/claude.rs +523 -0
  126. package/crates/team-agent/src/provider/session_scan/common.rs +44 -8
  127. package/crates/team-agent/src/provider/session_scan/pi.rs +34 -1
  128. package/crates/team-agent/src/provider/session_scan.rs +16 -6
  129. package/crates/team-agent/src/provider/tests/adapter.rs +104 -17
  130. package/crates/team-agent/src/provider/tests/classify.rs +0 -53
  131. package/crates/team-agent/src/provider/tests/command_helpers.rs +12 -3
  132. package/crates/team-agent/src/provider/tests/idle.rs +37 -0
  133. package/crates/team-agent/src/provider/wire.rs +22 -34
  134. package/crates/team-agent/src/state/abnormal_watch/tests/mod.rs +1 -1
  135. package/crates/team-agent/src/state/persist.rs +6 -6
  136. package/crates/team-agent/src/state/projection.rs +1 -1
  137. package/crates/team-agent/src/state/repository/tests.rs +2 -2
  138. package/crates/team-agent/src/test_support/models_timeout_fixture.rs +144 -0
  139. package/crates/team-agent/src/tmux_backend/tests.rs +0 -151
  140. package/crates/team-agent/src/tmux_backend.rs +5 -40
  141. package/package.json +4 -4
  142. package/skills/team-agent/SKILL.md +5 -7
  143. package/skills/team-agent/command-coverage.json +1 -1
  144. package/skills/team-agent/docs/reference/team-agent-operator.md +3 -3
  145. package/skills/team-agent/references/team-agent-operator.md +3 -3
@@ -0,0 +1,316 @@
1
+ //! Durable leader reminders; the existing coordinator is the only timer process.
2
+ use std::path::Path;
3
+
4
+ use chrono::{Duration, SecondsFormat, Utc};
5
+ use rusqlite::{params, OptionalExtension};
6
+ use serde::{Deserialize, Serialize};
7
+ use serde_json::{json, Value};
8
+
9
+ use super::MessagingError;
10
+ use crate::{event_log::EventLog, message_store::MessageStore};
11
+
12
+ #[derive(Serialize, Deserialize)]
13
+ struct Reminder {
14
+ text: String,
15
+ trigger: String,
16
+ interval_ms: Option<i64>,
17
+ }
18
+
19
+ pub(crate) fn parse_duration(raw: &str) -> Result<Duration, MessagingError> {
20
+ let split = raw.find(|c: char| !c.is_ascii_digit()).unwrap_or(raw.len());
21
+ let (amount, unit) = raw.split_at(split);
22
+ let multiplier = match unit {
23
+ "ms" => 1,
24
+ "s" => 1_000,
25
+ "m" => 60_000,
26
+ "h" => 3_600_000,
27
+ "d" => 86_400_000,
28
+ _ => 0,
29
+ };
30
+ amount.parse::<i64>().ok()
31
+ .and_then(|amount| amount.checked_mul(multiplier))
32
+ .filter(|ms| *ms > 0)
33
+ .and_then(Duration::try_milliseconds)
34
+ .filter(|duration| Utc::now().checked_add_signed(*duration).is_some())
35
+ .ok_or_else(|| MessagingError::Validation("duration must be a positive integer followed by ms, s, m, h or d, within the supported date range".into()))
36
+ }
37
+
38
+ pub(crate) fn parse_id(id: &str) -> Option<i64> {
39
+ let hex = id.strip_prefix("sched_")?;
40
+ if hex.is_empty() || !hex.bytes().all(|c| c.is_ascii_hexdigit()) {
41
+ return None;
42
+ }
43
+ i64::from_str_radix(hex, 16).ok().filter(|id| *id > 0)
44
+ }
45
+
46
+ fn view(id: i64, reminder: &Reminder) -> Value {
47
+ json!({"id": format!("sched_{id:x}"), "trigger": reminder.trigger,
48
+ "text": reminder.text, "status": "active"})
49
+ }
50
+
51
+ pub(crate) fn add(
52
+ workspace: &Path,
53
+ owner: &str,
54
+ text: &str,
55
+ duration: &str,
56
+ recurring: bool,
57
+ ) -> Result<Value, MessagingError> {
58
+ let interval = parse_duration(duration)?;
59
+ let now = Utc::now();
60
+ let due = now.checked_add_signed(interval).ok_or_else(|| {
61
+ MessagingError::Validation("duration exceeds supported date range".into())
62
+ })?;
63
+ let reminder = Reminder {
64
+ text: text.to_owned(),
65
+ trigger: format!("{} {duration}", if recurring { "every" } else { "in" }),
66
+ interval_ms: recurring.then_some(interval.num_milliseconds()),
67
+ };
68
+ let store = MessageStore::open(workspace)?;
69
+ let conn = crate::db::schema::open_db(store.db_path())?;
70
+ conn.execute(
71
+ "insert into scheduled_events (due_at, target, kind, payload_json, status, created_at, owner_team_id) values (?1, 'leader', 'reminder', ?2, 'pending', ?3, ?4)",
72
+ params![due.to_rfc3339_opts(SecondsFormat::Nanos, false), serde_json::to_string(&reminder)?, now.to_rfc3339(), owner],
73
+ )?;
74
+ let mut value = view(conn.last_insert_rowid(), &reminder);
75
+ value["ok"] = json!(true);
76
+ Ok(value)
77
+ }
78
+
79
+ pub(crate) fn list(workspace: &Path, owner: &str) -> Result<Vec<Value>, MessagingError> {
80
+ let store = MessageStore::open(workspace)?;
81
+ let conn = crate::db::schema::open_db(store.db_path())?;
82
+ let mut statement = conn.prepare("select id, payload_json from scheduled_events where kind='reminder' and owner_team_id=?1 and status='pending' order by id")?;
83
+ let rows = statement.query_map([owner], |row| {
84
+ Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?))
85
+ })?;
86
+ rows.map(|row| {
87
+ let (id, payload) = row?;
88
+ Ok(view(id, &serde_json::from_str(&payload)?))
89
+ })
90
+ .collect()
91
+ }
92
+
93
+ pub(crate) fn cancel(workspace: &Path, owner: &str, id: i64) -> Result<bool, MessagingError> {
94
+ let store = MessageStore::open(workspace)?;
95
+ let conn = crate::db::schema::open_db(store.db_path())?;
96
+ // An occurrence already fired is not recalled.
97
+ Ok(conn.execute("update scheduled_events set status='cancelled' where id=?1 and kind='reminder' and owner_team_id=?2 and status='pending'", params![id, owner])? == 1)
98
+ }
99
+
100
+ pub(super) fn fire(
101
+ workspace: &Path,
102
+ id: i64,
103
+ _event_log: &EventLog,
104
+ ) -> Result<Value, MessagingError> {
105
+ let store = MessageStore::open(workspace)?;
106
+ let mut conn = crate::db::schema::open_db(store.db_path())?;
107
+ // Serialize occurrences/cancellation, never wait for a delivery receipt.
108
+ let tx = conn.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
109
+ let row = tx.query_row(
110
+ "select due_at, payload_json, owner_team_id from scheduled_events where id=?1 and kind='reminder' and status='pending'",
111
+ [id], |row| Ok((row.get::<_, String>(0)?, row.get::<_, String>(1)?, row.get::<_, String>(2)?)),
112
+ ).optional()?;
113
+ let Some((due_at, payload, owner)) = row else {
114
+ return Ok(json!({"ok": true, "cancelled": true}));
115
+ };
116
+ let reminder: Reminder = serde_json::from_str(&payload)?;
117
+ let directory = crate::direct_delivery::directory(workspace, Some(&owner))
118
+ .map_err(MessagingError::Routing)?;
119
+ // The inbox is durable independently of physical delivery. A stable id also
120
+ // makes replay after an append/before timer commit safe without ledger rows.
121
+ let message_id = format!("reminder_{id}_{due_at}");
122
+ let inbox = crate::inbox_store::read(workspace, "leader", usize::MAX, Some(&owner))
123
+ .map_err(std::io::Error::other)?;
124
+ if !inbox["messages"].as_array().into_iter().flatten()
125
+ .any(|record| record["message_id"] == message_id)
126
+ {
127
+ let mut record = crate::inbox_store::record("scheduler", "leader", &reminder.text, Some(&owner), "reminder");
128
+ record["message_id"] = json!(message_id);
129
+ crate::inbox_store::append(workspace, "leader", &record)
130
+ .map_err(std::io::Error::other)?;
131
+ }
132
+ let next_due = reminder
133
+ .interval_ms
134
+ .and_then(Duration::try_milliseconds)
135
+ .filter(|duration| *duration > Duration::zero())
136
+ .and_then(|interval| Utc::now().checked_add_signed(interval))
137
+ .map(|due| due.to_rfc3339_opts(SecondsFormat::Nanos, false));
138
+ let mut result = json!({"ok": true, "message_id": message_id, "next_due_at": next_due, "delivery": "inbox"});
139
+ // Compare due_at as well as status: concurrent ticks or cancellation cannot
140
+ // advance the same occurrence twice, or resurrect a cancelled reminder.
141
+ tx.execute(
142
+ "update scheduled_events set status=?1, due_at=coalesce(?2, due_at), fired_at=?3, result_json=?4 where id=?5 and status='pending' and due_at=?6",
143
+ params![if next_due.is_some() { "pending" } else { "done" }, next_due, Utc::now().to_rfc3339(), result.to_string(), id, due_at],
144
+ )?;
145
+ tx.commit()?;
146
+ // Once consumed, physical delivery is best effort: a crash or detached pane
147
+ // still leaves the reminder in the inbox, never awaiting a legacy receipt.
148
+ match directory.send("leader", &format!("Team Agent reminder:\n\n{}", reminder.text)) {
149
+ Ok(_) => result["delivery"] = json!("physical"),
150
+ Err(error) => result["delivery_error"] = json!(error),
151
+ }
152
+ conn.execute(
153
+ "update scheduled_events set result_json=?1 where id=?2 and json_extract(result_json, '$.message_id')=?3",
154
+ params![result.to_string(), id, message_id],
155
+ )?;
156
+ Ok(result)
157
+ }
158
+
159
+ #[cfg(test)]
160
+ mod tests {
161
+ #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
162
+ use super::*;
163
+
164
+ struct TestWorkspace(std::path::PathBuf);
165
+ impl TestWorkspace {
166
+ fn path(&self) -> &Path {
167
+ &self.0
168
+ }
169
+ }
170
+ impl Drop for TestWorkspace {
171
+ fn drop(&mut self) {
172
+ let _ = std::fs::remove_dir_all(&self.0);
173
+ }
174
+ }
175
+ fn workspace() -> TestWorkspace {
176
+ static NEXT: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
177
+ let dir = TestWorkspace(std::env::temp_dir().join(format!(
178
+ "ta-reminders-{}-{}",
179
+ std::process::id(),
180
+ NEXT.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
181
+ )));
182
+ let state = json!({"active_team_key": "alpha", "team_key": "alpha", "teams": {
183
+ "alpha": {"team_key": "alpha", "agents": {}},
184
+ "beta": {"team_key": "beta", "agents": {}}
185
+ }});
186
+ let path = crate::state::persist::runtime_state_path(dir.path());
187
+ std::fs::create_dir_all(path.parent().unwrap()).unwrap();
188
+ std::fs::write(path, state.to_string()).unwrap();
189
+ dir
190
+ }
191
+
192
+ #[test]
193
+ fn durations_and_ids_are_strict_and_bounded() {
194
+ for (raw, milliseconds) in [
195
+ ("1ms", 1),
196
+ ("2s", 2000),
197
+ ("3m", 180000),
198
+ ("1h", 3600000),
199
+ ("1d", 86400000),
200
+ ] {
201
+ assert_eq!(
202
+ parse_duration(raw).unwrap().num_milliseconds(),
203
+ milliseconds
204
+ );
205
+ }
206
+ for raw in [
207
+ "",
208
+ "0s",
209
+ "-1s",
210
+ "1",
211
+ "1.5s",
212
+ "NaNs",
213
+ "1w",
214
+ "1s2m",
215
+ "999999999999999999999d",
216
+ "9223372036854775807ms",
217
+ ] {
218
+ assert!(parse_duration(raw).is_err(), "{raw}");
219
+ }
220
+ assert_eq!(parse_id("sched_1a"), Some(26));
221
+ for raw in [
222
+ "1",
223
+ "sched_",
224
+ "sched_-1",
225
+ "sched_+1",
226
+ "sched_0",
227
+ "sched_ffffffffffffffff",
228
+ ] {
229
+ assert_eq!(parse_id(raw), None, "{raw}");
230
+ }
231
+ }
232
+
233
+ #[test]
234
+ fn list_and_cancel_are_persistent_and_team_scoped() {
235
+ let dir = workspace();
236
+ let added = add(dir.path(), "alpha", "check status", "1h", true).unwrap();
237
+ assert_eq!(added["trigger"], "every 1h");
238
+ assert_eq!(added["status"], "active");
239
+ let id = parse_id(added["id"].as_str().unwrap()).unwrap();
240
+ assert_eq!(list(dir.path(), "alpha").unwrap().len(), 1);
241
+ assert!(list(dir.path(), "beta").unwrap().is_empty());
242
+ assert!(!cancel(dir.path(), "beta", id).unwrap());
243
+ assert!(cancel(dir.path(), "alpha", id).unwrap());
244
+ assert!(!cancel(dir.path(), "alpha", id).unwrap());
245
+ assert!(list(dir.path(), "alpha").unwrap().is_empty());
246
+ let log = EventLog::new(dir.path());
247
+ assert_eq!(fire(dir.path(), id, &log).unwrap()["cancelled"], true);
248
+ }
249
+
250
+ #[test]
251
+ fn one_shot_stores_once_and_uses_owner_not_active_team() {
252
+ let dir = workspace();
253
+ let added = add(dir.path(), "beta", "beta reminder", "1ms", false).unwrap();
254
+ let id = parse_id(added["id"].as_str().unwrap()).unwrap();
255
+ let log = EventLog::new(dir.path());
256
+ let result = fire(dir.path(), id, &log).unwrap();
257
+ assert_eq!(result["delivery"], "inbox");
258
+ assert!(result["delivery_error"].is_string());
259
+ fire(dir.path(), id, &log).unwrap();
260
+ let inbox = crate::inbox_store::read(dir.path(), "leader", usize::MAX, None).unwrap();
261
+ let records = inbox["messages"].as_array().unwrap();
262
+ assert_eq!(records.len(), 1);
263
+ assert_eq!(records[0]["team"], "beta");
264
+ assert_eq!(records[0]["recipient"], "leader");
265
+ assert_eq!(records[0]["kind"], "reminder");
266
+ assert_eq!(records[0]["content"], "beta reminder");
267
+ let store = MessageStore::open(dir.path()).unwrap();
268
+ let conn = crate::db::schema::open_db(store.db_path()).unwrap();
269
+ assert_eq!(conn.query_row("select count(*) from messages", [], |row| row.get::<_, i64>(0)).unwrap(), 0);
270
+ assert!(list(dir.path(), "beta").unwrap().is_empty());
271
+ }
272
+
273
+ #[test]
274
+ fn recurring_occurrences_are_unique_and_crash_replay_is_idempotent() {
275
+ let dir = workspace();
276
+ let added = add(dir.path(), "alpha", "periodic", "1s", true).unwrap();
277
+ let id = parse_id(added["id"].as_str().unwrap()).unwrap();
278
+ let log = EventLog::new(dir.path());
279
+ let store = MessageStore::open(dir.path()).unwrap();
280
+ let conn = crate::db::schema::open_db(store.db_path()).unwrap();
281
+ let original_due: String = conn.query_row(
282
+ "select due_at from scheduled_events where id=?1", [id], |row| row.get(0),
283
+ ).unwrap();
284
+ let count = || crate::inbox_store::read(dir.path(), "leader", usize::MAX, None).unwrap()["messages"].as_array().unwrap().len();
285
+ fire(dir.path(), id, &log).unwrap();
286
+ assert_eq!(list(dir.path(), "alpha").unwrap().len(), 1);
287
+ // Simulate the crash window after inbox append, before timer commit.
288
+ conn.execute("update scheduled_events set due_at=?1 where id=?2", params![original_due, id]).unwrap();
289
+ fire(dir.path(), id, &log).unwrap();
290
+ assert_eq!(count(), 1);
291
+ fire(dir.path(), id, &log).unwrap();
292
+ assert_eq!(count(), 2);
293
+ assert!(cancel(dir.path(), "alpha", id).unwrap());
294
+ fire(dir.path(), id, &log).unwrap();
295
+ assert_eq!(count(), 2);
296
+ assert_eq!(conn.query_row("select count(*) from messages", [], |row| row.get::<_, i64>(0)).unwrap(), 0);
297
+ }
298
+
299
+ #[test]
300
+ fn concurrent_fires_consume_one_occurrence_and_one_inbox_record() {
301
+ let dir = workspace();
302
+ let added = add(dir.path(), "alpha", "once", "1ms", false).unwrap();
303
+ let id = parse_id(added["id"].as_str().unwrap()).unwrap();
304
+ let barrier = std::sync::Barrier::new(2);
305
+ std::thread::scope(|scope| {
306
+ let handles: Vec<_> = (0..2).map(|_| scope.spawn(|| {
307
+ barrier.wait();
308
+ fire(dir.path(), id, &EventLog::new(dir.path())).unwrap()
309
+ })).collect();
310
+ let results: Vec<_> = handles.into_iter().map(|handle| handle.join().unwrap()).collect();
311
+ assert_eq!(results.iter().filter(|result| result["cancelled"] == true).count(), 1);
312
+ });
313
+ let inbox = crate::inbox_store::read(dir.path(), "leader", usize::MAX, None).unwrap();
314
+ assert_eq!(inbox["messages"].as_array().unwrap().len(), 1);
315
+ }
316
+ }
@@ -53,6 +53,7 @@ pub fn fire_due_scheduled_events(
53
53
  let fire_one = || -> Result<serde_json::Value, MessagingError> {
54
54
  let scheduled_kind = parse_scheduled_kind(&kind)?;
55
55
  let result = match scheduled_kind {
56
+ ScheduledKind::Reminder => super::reminders::fire(workspace, id, event_log)?,
56
57
  ScheduledKind::Send => {
57
58
  let payload: serde_json::Value = serde_json::from_str(&payload_json)?;
58
59
  let outcome = deliver_stored_message(
@@ -132,6 +133,11 @@ pub fn fire_due_scheduled_events(
132
133
 
133
134
  let (status, result_json) = match fire_one() {
134
135
  Ok(result) => {
136
+ // Reminder dispatch owns recurrence advancement and cancellation.
137
+ if kind == "reminder" {
138
+ fired.push(id);
139
+ continue;
140
+ }
135
141
  let ok = result
136
142
  .get("ok")
137
143
  .and_then(serde_json::Value::as_bool)
@@ -158,7 +164,7 @@ pub fn fire_due_scheduled_events(
158
164
  // The row-status write stays `?`: a DB write failure is a real store fault, not a
159
165
  // per-event poison, and should surface (consistent with the rest of the fn).
160
166
  conn.execute(
161
- "update scheduled_events set status = ?2, fired_at = ?3, result_json = ?4 where id = ?1",
167
+ "update scheduled_events set status = ?2, fired_at = ?3, result_json = ?4 where id = ?1 and status = 'pending'",
162
168
  params![id, status, chrono::Utc::now().to_rfc3339(), result_json],
163
169
  )?;
164
170
  fired.push(id);
@@ -30,7 +30,7 @@ use crate::transport::{
30
30
 
31
31
  #[test]
32
32
  #[cfg(unix)]
33
- fn eager_mcp_waits_without_spending_input_attempts_then_delivers_the_same_message() {
33
+ fn issue372_missing_mcp_receipt_delivers_immediately_without_duplicate_input() {
34
34
  let mut case = WorkerCase::new("mcp-handshake", "copilot");
35
35
  let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
36
36
  let config = case.workspace.join(".team/runtime/mcp/w1.json");
@@ -44,112 +44,218 @@ fn eager_mcp_waits_without_spending_input_attempts_then_delivers_the_same_messag
44
44
  case.state["team_key"] = serde_json::json!("dup-team");
45
45
  case.state["agents"]["w1"]["mcp_config"] = serde_json::json!(config);
46
46
  case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
47
- case.state["agents"]["w1"]["spawned_at"] = serde_json::json!((chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
47
+ case.state["agents"]["w1"]["spawned_at"] =
48
+ serde_json::json!((chrono::Utc::now() - chrono::Duration::seconds(10)).to_rfc3339());
48
49
  case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
49
50
  crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
50
- let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
51
- let message_id = case.store.create_message(None, "leader", "w1", "handshake canary", None, false, Some("dup-team")).unwrap();
51
+ let transport = RecordingTransport {
52
+ carrier: Some(carrier),
53
+ ..RecordingTransport::new("")
54
+ };
55
+ let message_id = case
56
+ .store
57
+ .create_message(
58
+ None,
59
+ "leader",
60
+ "w1",
61
+ "handshake canary",
62
+ None,
63
+ false,
64
+ Some("dup-team"),
65
+ )
66
+ .unwrap();
52
67
  for _ in 0..3 {
53
- let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
54
- &message_id, &case.event_log, &case.state).unwrap();
55
- assert!(!outcome.ok);
56
- assert!(outcome.verification.as_deref().unwrap().starts_with("mcp_handshake_"));
57
- assert_eq!(transport.inject_count(), 0);
68
+ let outcome = deliver_pending_message(
69
+ &case.workspace,
70
+ &case.store,
71
+ &transport,
72
+ &message_id,
73
+ &case.event_log,
74
+ &case.state,
75
+ )
76
+ .unwrap();
77
+ assert_eq!(
78
+ transport.inject_count(),
79
+ 1,
80
+ "live pane must receive input immediately: {outcome:?}"
81
+ );
58
82
  }
59
83
  let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
60
- let attempts: i64 = connection.query_row("select delivery_attempts from messages where message_id=?1", [&message_id], |row| row.get(0)).unwrap();
61
- assert_eq!(attempts, 0, "waiting is not a physical delivery attempt");
62
- crate::mcp_server::readiness::publish(&case.workspace, "dup-team", "w1", chrono::Utc::now()).unwrap();
63
- let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
64
- &message_id, &case.event_log, &case.state).unwrap();
84
+ let attempts: i64 = connection
85
+ .query_row(
86
+ "select delivery_attempts from messages where message_id=?1",
87
+ [&message_id],
88
+ |row| row.get(0),
89
+ )
90
+ .unwrap();
91
+ assert_eq!(
92
+ attempts, 1,
93
+ "readiness must not park or refund the delivery"
94
+ );
95
+ assert!(case.events().contains("delivery.mcp_handshake_warning"));
96
+ assert!(!case.events().contains("delivery.deferred_mcp_handshake"));
97
+ crate::mcp_server::readiness::publish(&case.workspace, "dup-team", "w1", chrono::Utc::now())
98
+ .unwrap();
99
+ let outcome = deliver_pending_message(
100
+ &case.workspace,
101
+ &case.store,
102
+ &transport,
103
+ &message_id,
104
+ &case.event_log,
105
+ &case.state,
106
+ )
107
+ .unwrap();
65
108
  assert_eq!(outcome.message_id.as_deref(), Some(message_id.as_str()));
66
- assert_eq!(transport.inject_count(), 1, "same queued row proceeds after the real receipt");
109
+ assert_eq!(
110
+ transport.inject_count(),
111
+ 1,
112
+ "late receipt must not replay an already injected row"
113
+ );
67
114
  }
68
115
 
69
116
  #[test]
70
117
  #[cfg(unix)]
71
- fn issue372_bounded_handshake_wait_parks_notifies_once_then_publish_delivers() {
72
- let mut case = WorkerCase::new("mcp-handshake-park", "copilot");
118
+ fn issue372_missing_mcp_config_is_diagnostic_not_a_delivery_gate() {
119
+ let mut case = WorkerCase::new("missing-mcp-config", "copilot");
73
120
  let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
74
- let config = case.workspace.join(".team/runtime/mcp/w1.json");
75
- std::fs::create_dir_all(config.parent().unwrap()).unwrap();
76
- std::fs::write(&config, serde_json::to_vec(&serde_json::json!({
77
- "mcpServers": {"team_orchestrator": {
78
- "command": std::env::current_exe().unwrap().canonicalize().unwrap(),
79
- "env": {"TEAM_AGENT_WORKSPACE": case.workspace, "TEAM_AGENT_ID": "w1", "TEAM_AGENT_OWNER_TEAM_ID": "dup-team"}
80
- }}
81
- })).unwrap()).unwrap();
82
- let long_ago = (chrono::Utc::now() - chrono::Duration::seconds(400)).to_rfc3339();
83
121
  case.state["team_key"] = serde_json::json!("dup-team");
84
- case.state["agents"]["w1"]["mcp_config"] = serde_json::json!(config);
85
122
  case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
86
- case.state["agents"]["w1"]["spawned_at"] = serde_json::json!(long_ago);
123
+ case.state["agents"]["w1"]["spawned_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
87
124
  case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
88
125
  crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
89
- let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
90
- let ids: Vec<String> = (0..2)
91
- .map(|n| case.store.create_message(None, "leader", "w1", &format!("parked canary {n}"), None, false, Some("dup-team")).unwrap())
92
- .collect();
93
- let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
94
- connection.execute("update messages set created_at = ?1", [&long_ago]).unwrap();
95
- for id in &ids {
96
- let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
97
- id, &case.event_log, &case.state).unwrap();
98
- assert_eq!(outcome.message_status.0, "queued_until_start", "{outcome:?}");
99
- assert!(outcome.verification.as_deref().unwrap().starts_with("mcp_handshake_timeout:mcp_handshake_"));
100
- }
101
- assert_eq!(transport.inject_count(), 0, "a parked wait never reaches input");
102
- let row = |id: &str| -> (String, Option<String>, i64) {
103
- connection.query_row(
104
- "select status, error, delivery_attempts from messages where message_id = ?1",
105
- [id], |r| Ok((r.get(0)?, r.get(1)?, r.get(2)?)),
106
- ).unwrap()
126
+ let transport = RecordingTransport {
127
+ carrier: Some(carrier),
128
+ ..RecordingTransport::new("")
107
129
  };
108
- for id in &ids {
109
- assert_eq!(row(id.as_str()), ("queued_until_start".to_string(), Some("mcp_handshake_timeout".to_string()), 0));
130
+ let message_id = case
131
+ .store
132
+ .create_message(
133
+ None,
134
+ "leader",
135
+ "w1",
136
+ "missing config canary",
137
+ None,
138
+ false,
139
+ Some("dup-team"),
140
+ )
141
+ .unwrap();
142
+ for _ in 0..3 {
143
+ let outcome = deliver_pending_message(
144
+ &case.workspace,
145
+ &case.store,
146
+ &transport,
147
+ &message_id,
148
+ &case.event_log,
149
+ &case.state,
150
+ )
151
+ .unwrap();
152
+ assert_eq!(
153
+ transport.inject_count(),
154
+ 1,
155
+ "missing metadata cannot block a live pane: {outcome:?}"
156
+ );
110
157
  }
111
- let events = case.events();
112
- assert_eq!(events.matches("\"delivery.mcp_handshake_parked\"").count(), 2, "{events}");
113
- assert_eq!(events.matches("\"delivery.mcp_handshake_parked_notification\"").count(), 1,
114
- "one leader notice per seat spawn: {events}");
115
- let notices: i64 = connection.query_row(
116
- "select count(*) from leader_notification_log where result_id like 'mcp_handshake.timeout:w1:%'",
117
- [], |r| r.get(0),
118
- ).unwrap();
119
- assert_eq!(notices, 1);
158
+ let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
159
+ let attempts: i64 = connection
160
+ .query_row(
161
+ "select delivery_attempts from messages where message_id=?1",
162
+ [&message_id],
163
+ |row| row.get(0),
164
+ )
165
+ .unwrap();
166
+ assert_eq!(attempts, 1, "metadata must not suppress or duplicate input");
167
+ assert!(case.events().contains("mcp_handshake_config_missing"));
168
+ }
120
169
 
121
- crate::mcp_server::readiness::publish(&case.workspace, "dup-team", "w1", chrono::Utc::now()).unwrap();
122
- for id in &ids {
123
- assert_eq!(row(id.as_str()).0, "accepted", "a fresh receipt resumes parked rows");
170
+ #[test]
171
+ #[cfg(unix)]
172
+ fn issue372_bad_receipts_never_park_live_pane_delivery() {
173
+ for fault in ["dead", "ancestry", "malformed"] {
174
+ let mut case = WorkerCase::new(fault, "copilot");
175
+ let pane = crate::mcp_server::readiness::test_ready_worker(
176
+ &case.workspace,
177
+ &mut case.state,
178
+ "dup-team",
179
+ "w1",
180
+ "%w1",
181
+ );
182
+ crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
183
+ let receipt = std::fs::read_dir(case.workspace.join(".team/runtime/mcp-handshakes"))
184
+ .unwrap()
185
+ .map(|entry| entry.unwrap().path())
186
+ .find(|path| path.extension().is_some_and(|ext| ext == "json"))
187
+ .unwrap();
188
+ let mut value: serde_json::Value =
189
+ serde_json::from_slice(&std::fs::read(&receipt).unwrap()).unwrap();
190
+ match fault {
191
+ "dead" => value["server"]["identity"]["pid"] = serde_json::json!(u32::MAX),
192
+ "ancestry" => value["ancestors"] = serde_json::json!([]),
193
+ _ => value = serde_json::json!("invalid receipt"),
194
+ }
195
+ std::fs::write(receipt, serde_json::to_vec(&value).unwrap()).unwrap();
196
+ let transport = RecordingTransport {
197
+ carrier: pane.pane_pid,
198
+ ..RecordingTransport::new("")
199
+ };
200
+ let message_id = case
201
+ .store
202
+ .create_message(
203
+ None,
204
+ "leader",
205
+ "w1",
206
+ "bad receipt canary",
207
+ None,
208
+ false,
209
+ Some("dup-team"),
210
+ )
211
+ .unwrap();
212
+ for _ in 0..2 {
213
+ deliver_pending_message(
214
+ &case.workspace,
215
+ &case.store,
216
+ &transport,
217
+ &message_id,
218
+ &case.event_log,
219
+ &case.state,
220
+ )
221
+ .unwrap();
222
+ assert_eq!(
223
+ transport.inject_count(),
224
+ 1,
225
+ "{fault} must not block or duplicate input"
226
+ );
227
+ }
228
+ assert!(
229
+ case.events().contains("delivery.mcp_handshake_warning"),
230
+ "{fault}"
231
+ );
232
+ assert!(
233
+ !case.events().contains("delivery.deferred_mcp_handshake"),
234
+ "{fault}"
235
+ );
236
+ let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
237
+ let (status, attempts): (String, i64) = connection
238
+ .query_row(
239
+ "SELECT status,delivery_attempts FROM messages WHERE message_id=?1",
240
+ [&message_id],
241
+ |row| Ok((row.get(0)?, row.get(1)?)),
242
+ )
243
+ .unwrap();
244
+ assert_ne!(status, "target_resolved", "{fault}");
245
+ assert_eq!(attempts, 1, "{fault}");
124
246
  }
125
- let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
126
- &ids[0], &case.event_log, &case.state).unwrap();
127
- assert_eq!(outcome.message_id.as_deref(), Some(ids[0].as_str()));
128
- assert_eq!(transport.inject_count(), 1, "the same parked row is delivered after the receipt");
129
247
  }
130
248
 
131
249
  #[test]
132
- #[cfg(unix)]
133
- fn issue345_missing_eager_config_defers_without_input_or_attempts() {
134
- let mut case = WorkerCase::new("missing-mcp-config", "copilot");
135
- let carrier = crate::mcp_server::readiness::test_carrier_pid().unwrap();
136
- case.state["team_key"] = serde_json::json!("dup-team");
137
- case.state["agents"]["w1"]["pane_pid"] = serde_json::json!(carrier);
138
- case.state["agents"]["w1"]["spawned_at"] = serde_json::json!(chrono::Utc::now().to_rfc3339());
139
- case.state["teams"] = serde_json::json!({"dup-team": case.state.clone()});
140
- crate::state::persist::save_runtime_state(&case.workspace, &case.state).unwrap();
141
- let transport = RecordingTransport { carrier: Some(carrier), ..RecordingTransport::new("") };
142
- let message_id = case.store.create_message(None, "leader", "w1", "missing config canary", None, false, Some("dup-team")).unwrap();
143
- for _ in 0..3 {
144
- let outcome = deliver_pending_message(&case.workspace, &case.store, &transport,
145
- &message_id, &case.event_log, &case.state).unwrap();
146
- assert!(!outcome.ok);
147
- assert!(outcome.verification.as_deref().unwrap().starts_with("mcp_handshake_"));
148
- assert_eq!(transport.inject_count(), 0, "missing metadata must never reach input");
250
+ fn issue372_existing_timeout_rows_resume_without_republication() {
251
+ let case = WorkerCase::new("legacy-timeout", "fake");
252
+ let transport = RecordingTransport::new("");
253
+ let message_id = case.seed_leader_to_worker("legacy parked canary");
254
+ case.store.mark(&message_id, "queued_until_start", Some(crate::message_store::MCP_HANDSHAKE_TIMEOUT)).unwrap();
255
+ for _ in 0..2 {
256
+ crate::messaging::deliver_pending_messages(&case.workspace, &case.state, &transport, &case.event_log).unwrap();
257
+ assert_eq!(transport.inject_count(), 1);
149
258
  }
150
- let connection = rusqlite::Connection::open(case.store.db_path()).unwrap();
151
- let attempts: i64 = connection.query_row("select delivery_attempts from messages where message_id=?1", [&message_id], |row| row.get(0)).unwrap();
152
- assert_eq!(attempts, 0, "metadata wait is not an input attempt");
153
259
  }
154
260
 
155
261
  #[test]
@@ -294,7 +400,7 @@ fn pane_token_refuses_second_inject_for_copilot() {
294
400
 
295
401
  #[test]
296
402
  fn transcript_token_refuses_second_inject() {
297
- let case = WorkerCase::new("transcript", "copilot");
403
+ let case = WorkerCase::new("transcript", "claude");
298
404
  let message_id = case.seed_leader_to_worker("transcript canary");
299
405
  std::fs::write(
300
406
  &case.rollout,