mcp: stop a land for overlaps the agent has not seen (pre-flight)

changelog.d/mcp-preflight.md

@@ -0,0 +1,18 @@
+### MCP lands stop for overlaps the agent has not seen
+- **Changed.** `leep_commit_and_land` and `leep_resolve_and_land` check
+  the notices their commit got before landing (ADR 0096 amendment): a
+  possible duplicate, a claim on or another session on one of the
+  changed files, or a land on one of them since the base, not shown to
+  the agent before, stops the call with `status: stopped` (not an
+  error), the changeset it made, its ref and every such notice. The
+  stopped changeset lands only with `force: true`; calling again reuses
+  it, and without `force` stops again. `near`, directory scopes and
+  related files never stop a land.
+- **Changed.** A changeset create's answer carries every notice that
+  stops a land of its files, past the cap of three, and a notice is said
+  again when it comes to stop a file it did not stop before. Notices name
+  the file two sessions share rather than a directory holding it, and a
+  `landed` notice names the request's file it changed.
+- **Fixed.** `leep_task_start` asks once more for a context pack the
+  server shed with a `Retry-After` of at most 2 s, instead of reporting
+  "Context unavailable" at once.

crates/leep-cli/src/client.rs

@@ -547,6 +547,12 @@ impl Client {
         all
     }
 
+    /// The notices gathered so far, left for [`Client::take_notices`]: for
+    /// a caller that decides something on them before they are shown.
+    pub fn pending_notices(&self) -> Vec<Notice> {
+        self.notices.lock().unwrap().clone()
+    }
+
     /// Forget the gathered notices `shown` says were already shown (in a
     /// context pack printed with them), so none is said twice.
     pub fn forget_notices(&self, shown: impl Fn(&Notice) -> bool) {

crates/leep-core/src/api.rs

@@ -1257,6 +1257,59 @@ pub struct Notice {
     pub untrusted: NoticeText,
 }
 
+impl Notice {
+    /// Whether this notice stops an agent's land before it happens (the
+    /// pre-flight check, ADR 0096 amendment), for a change of the files
+    /// `changes`. The one place the rule lives:
+    /// - `possible_duplicate`, and a duplicate's land (`landed` by
+    ///   `task_key`), always stop;
+    /// - otherwise [`path_stops_land`] on the other side's path
+    ///   (`untrusted.other_path`);
+    /// - anything met only through a related file (`via`) never stops.
+    ///
+    /// Only the other side's path is read, never which of mine the server
+    /// paired it with, so a notice found through a directory of mine still
+    /// stops when their path is one of my files. The paths compared are
+    /// agent-written (`untrusted`): they decide only whether to stop, never
+    /// what is shown outside the fence.
+    pub fn stops_land<S: AsRef<str>>(&self, changes: &[S]) -> bool {
+        if self.via.is_some() {
+            return false;
+        }
+        if self.level == "possible_duplicate"
+            || (self.level == "landed" && self.by.as_deref() == Some("task_key"))
+        {
+            return true;
+        }
+        self.untrusted
+            .other_path
+            .as_deref()
+            .is_some_and(|theirs| path_stops_land(&self.level, theirs, changes))
+    }
+}
+
+/// Whether another side's path `theirs`, met at `level`, stops a land of
+/// the files `changes` ([`Notice::stops_land`]): `landed` and `same_file`
+/// when `theirs` is one of the files itself (a directory someone scoped
+/// does not stop), `claimed` when it is one of them or a directory holding
+/// one; `near` and levels not known here never.
+pub fn path_stops_land<S: AsRef<str>>(level: &str, theirs: &str, changes: &[S]) -> bool {
+    let theirs = theirs.trim_end_matches('/');
+    let is = |c: &S| c.as_ref() == theirs;
+    let holds = |c: &S| {
+        let c = c.as_ref();
+        theirs.is_empty()
+            || (c.len() > theirs.len()
+                && c.starts_with(theirs)
+                && c.as_bytes()[theirs.len()] == b'/')
+    };
+    match level {
+        "landed" | "same_file" => changes.iter().any(is),
+        "claimed" => changes.iter().any(|c| is(c) || holds(c)),
+        _ => false,
+    }
+}
+
 /// `GET /v1/notices`: the notices for the caller's session named by
 /// `Leep-Session`, each said once (ADR 0096).
 #[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
@@ -2155,6 +2208,52 @@ pub struct SearchResponse {
 mod tests {
     use super::*;
 
+    #[test]
+    fn which_notices_stop_a_land() {
+        let n = |level: &str, mine: &str, theirs: &str| Notice {
+            level: level.into(),
+            session: Some(1),
+            principal: None,
+            changeset: None,
+            count: None,
+            by: None,
+            similarity: None,
+            via: None,
+            landed_on: None,
+            untrusted: NoticeText {
+                path: Some(mine.into()),
+                other_path: Some(theirs.into()),
+                ..Default::default()
+            },
+        };
+        let changes = ["src/a.rs"];
+        // Their own file is mine, whichever of mine it was paired with; a
+        // scope above it is not enough.
+        assert!(n("same_file", "src/a.rs", "src/a.rs").stops_land(&changes));
+        assert!(n("same_file", "src", "src/a.rs").stops_land(&changes));
+        assert!(!n("same_file", "src/a.rs", "src").stops_land(&changes));
+        assert!(!n("same_file", "src", "src/b.rs").stops_land(&changes));
+        // A claim on my file or a directory above it.
+        assert!(n("claimed", "src/a.rs", "src").stops_land(&changes));
+        assert!(n("claimed", "src/a.rs", "src/").stops_land(&changes));
+        assert!(n("claimed", "src", "src/a.rs").stops_land(&changes));
+        assert!(!n("claimed", "src", "src/b.rs").stops_land(&changes));
+        assert!(!n("claimed", "src/a.rs", "sr").stops_land(&changes));
+        assert!(n("possible_duplicate", "src", "src").stops_land(&changes));
+        assert!(n("landed", "src", "src/a.rs").stops_land(&changes));
+        assert!(!n("landed", "src", "src/b.rs").stops_land(&changes));
+        let mut dup_land = n("landed", "src", "src/b.rs");
+        dup_land.by = Some("task_key".into());
+        assert!(dup_land.stops_land(&changes));
+        // Never: near, an unknown level, a related file, no changes.
+        assert!(!n("near", "src/a.rs", "src/a.rs").stops_land(&changes));
+        assert!(!n("conflict", "src/a.rs", "src/a.rs").stops_land(&changes));
+        let mut related = n("claimed", "src/a.rs", "src/a.rs");
+        related.via = Some("related".into());
+        assert!(!related.stops_land(&changes));
+        assert!(!n("claimed", "src/a.rs", "src").stops_land::<&str>(&[]));
+    }
+
     #[test]
     fn rebase_onto_shapes_are_stable() {
         let a = ChangesetId(Hash::of_blob(b"a"));