agrep 0.4.0__tar.gz → 0.4.2__tar.gz

{agrep-0.4.0 → agrep-0.4.2}/Cargo.lock

@@ -10,7 +10,7 @@ checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
 
 [[package]]
 name = "agrep-core"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "anyhow",
  "bincode",
@@ -30,7 +30,7 @@ dependencies = [
 
 [[package]]
 name = "agrep-ingest"
-version = "0.4.0"
+version = "0.4.2"
 dependencies = [
  "agrep-core",
  "anyhow",

{agrep-0.4.0 → agrep-0.4.2}/Cargo.toml

@@ -4,7 +4,7 @@ resolver = "2"
 
 [workspace.package]
 edition = "2021"
-version = "0.4.0"
+version = "0.4.2"
 license = "MIT"
 
 [workspace.dependencies]

{agrep-0.4.0 → agrep-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agrep
-Version: 0.4.0
+Version: 0.4.2
 Summary: Find, open, resume and watch your AI agents' work across Claude, Codex, opencode, Antigravity, Kimi, Cline, Gemini, Crush, Cursor, pi and oh-my-pi - one local index.
 Project-URL: Homepage, https://github.com/dannyisbad/agrep
 Project-URL: Repository, https://github.com/dannyisbad/agrep

{agrep-0.4.0 → agrep-0.4.2}/agrep/__init__.py

@@ -5,4 +5,4 @@ binary, so `uvx agrep` / `pipx run agrep` / `pip install agrep` need no clone or
 The real logic lives in the bundled modules; see __main__.py.
 """
 
-__version__ = "0.4.0"
+__version__ = "0.4.2"

{agrep-0.4.0 → agrep-0.4.2}/crates/agrep-cli/src/index_lock.rs

@@ -77,6 +77,12 @@ pub(crate) fn current_process_start_identity() -> Option<String> {
     process_start_identity(std::process::id())
 }
 
+pub(crate) fn process_is_exact_live(pid: u32, start: &str) -> bool {
+    !["", "None", "unknown"].contains(&start)
+        && process_liveness(pid) == Liveness::Alive
+        && process_start_identity(pid).as_deref() == Some(start)
+}
+
 pub(crate) fn observe_live_holder(path: &Path, label: &str) -> io::Result<Option<LiveHolder>> {
     let observed = match snapshot(path) {
         Ok(observed) => observed,

{agrep-0.4.0 → agrep-0.4.2}/crates/agrep-cli/src/main.rs

@@ -228,6 +228,7 @@ const ROOT_STAGING_ARTIFACTS: &[&str] = &[
     ".source_absence_pending",
     ".source-health.json",
     ".source_snapshot.bin",
+    ".source_snapshot.seal",
     ".token_material.json",
     "boundary_stats.json",
     "corpus.db",
@@ -256,6 +257,7 @@ const CORPUS_DB_TRIGGER_NAMES: [&str; 7] = [
 ];
 const DERIVED_ADOPTION_OWNER_TOKEN_ENV: &str = "AGREP_DERIVED_ADOPTION_OWNER_TOKEN";
 const DERIVED_ADOPTION_CLAIM_TOKEN_ENV: &str = "AGREP_DERIVED_ADOPTION_CLAIM_TOKEN";
+const DERIVED_ADOPTION_WAIT_MS_ENV: &str = "AGREP_DERIVED_ADOPTION_WAIT_MS";
 const DERIVED_WRITER_IDENTITY_BLOCKED_ENV: &str = "AGREP_DERIVED_WRITER_IDENTITY_BLOCKED";
 
 #[derive(serde::Deserialize, serde::Serialize)]
@@ -891,7 +893,13 @@ fn read_daemon_owner_fields(path: &Path, name: &str) -> Result<HashMap<String, S
         }
     };
     let text = match std::str::from_utf8(&body) {
-        Ok(text) if text.ends_with('\n') => text,
+        Ok(text)
+            if text.ends_with('\n')
+                && text.bytes().filter(|byte| *byte == b'\n').count() == 1
+                && !text.contains('\0') =>
+        {
+            text
+        }
         _ => return Err(format!("freshness-daemon owner {name} is malformed")),
     };
     let mut fields = HashMap::new();
@@ -908,15 +916,85 @@ fn read_daemon_owner_fields(path: &Path, name: &str) -> Result<HashMap<String, S
     Ok(fields)
 }
 
-fn adoption_daemon_fence(data: &Path) -> Option<String> {
+#[derive(Debug, PartialEq, Eq)]
+enum AdoptionFence {
+    LiveSameWriter(u32),
+    Refused(String),
+}
+
+impl From<String> for AdoptionFence {
+    fn from(reason: String) -> Self {
+        Self::Refused(reason)
+    }
+}
+
+impl std::fmt::Display for AdoptionFence {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::LiveSameWriter(pid) => {
+                write!(f, "this build is already adopting the index (pid {pid})")
+            }
+            Self::Refused(reason) => f.write_str(reason),
+        }
+    }
+}
+
+fn live_same_writer_adoption(owners: &[(String, PathBuf)], writer: &str) -> Option<u32> {
+    let mut claim = None;
+    for (name, path) in owners {
+        if !matches!(name.as_str(), ".indexd.lock" | ".indexd.v2.lock") {
+            return None;
+        }
+        let fields = read_daemon_owner_fields(path, name).ok()?;
+        let pid_text = fields.get("pid")?;
+        if !pid_text.bytes().all(|byte| byte.is_ascii_digit()) {
+            return None;
+        }
+        let pid = pid_text.parse::<u32>().ok()?;
+        let start = fields.get("start")?;
+        let token = fields.get("token")?;
+        if pid == 0
+            || pid > index_lock::MAX_PID
+            || !index_lock::process_is_exact_live(pid, start)
+            || fields.get("writer").map(String::as_str) != Some(writer)
+            || token.len() != 32
+            || !token
+                .bytes()
+                .all(|byte| byte.is_ascii_digit() || (b'a'..=b'f').contains(&byte))
+        {
+            return None;
+        }
+        if fields.get("state").map(String::as_str) == Some("derived-adoption") {
+            if fields.len() != 5 {
+                return None;
+            }
+            let identity = (pid, token.clone());
+            if claim.as_ref().is_some_and(|prior| prior != &identity) {
+                return None;
+            }
+            claim = Some(identity);
+        } else if name != ".indexd.v2.lock"
+            || fields.get("protocol").map(String::as_str) != Some("2")
+            || std::env::var(DERIVED_ADOPTION_OWNER_TOKEN_ENV).as_deref() != Ok(token.as_str())
+        {
+            return None;
+        }
+    }
+    claim.map(|(pid, _)| pid)
+}
+
+fn adoption_daemon_fence(data: &Path) -> Option<AdoptionFence> {
     let entries = match fs::read_dir(data) {
         Ok(entries) => entries,
         Err(error) if error.kind() == std::io::ErrorKind::NotFound => return None,
         Err(error) => {
-            return Some(format!(
-                "cannot inspect freshness-daemon ownership in {}: {error}",
-                data.display()
-            ));
+            return Some(
+                format!(
+                    "cannot inspect freshness-daemon ownership in {}: {error}",
+                    data.display()
+                )
+                .into(),
+            );
         }
     };
     let mut owners = Vec::new();
@@ -924,10 +1002,13 @@ fn adoption_daemon_fence(data: &Path) -> Option<String> {
         let entry = match entry {
             Ok(entry) => entry,
             Err(error) => {
-                return Some(format!(
-                    "cannot inspect freshness-daemon ownership in {}: {error}",
-                    data.display()
-                ));
+                return Some(
+                    format!(
+                        "cannot inspect freshness-daemon ownership in {}: {error}",
+                        data.display()
+                    )
+                    .into(),
+                );
             }
         };
         let Some(name) = entry.file_name().to_str().map(str::to_owned) else {
@@ -940,10 +1021,13 @@ fn adoption_daemon_fence(data: &Path) -> Option<String> {
                 Ok(false) => owners.push((name, path)),
                 Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue,
                 Err(error) => {
-                    return Some(format!(
-                        "cannot inspect freshness-daemon owner {}: {error}",
-                        path.display()
-                    ));
+                    return Some(
+                        format!(
+                            "cannot inspect freshness-daemon owner {}: {error}",
+                            path.display()
+                        )
+                        .into(),
+                    );
                 }
             }
         }
@@ -978,25 +1062,34 @@ fn adoption_daemon_fence(data: &Path) -> Option<String> {
     if external.is_empty() {
         return None;
     }
+    if let Some(pid) = live_same_writer_adoption(&external, &current) {
+        return Some(AdoptionFence::LiveSameWriter(pid));
+    }
     if external.len() != 1 || external[0].0 == ".indexd.lock" {
-        return Some(format!(
-            "legacy or ambiguous freshness-daemon ownership is present ({})",
-            external
-                .iter()
-                .map(|(name, _)| name.as_str())
-                .collect::<Vec<_>>()
-                .join(", ")
-        ));
+        return Some(
+            format!(
+                "legacy or ambiguous freshness-daemon ownership is present ({})",
+                external
+                    .iter()
+                    .map(|(name, _)| name.as_str())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            )
+            .into(),
+        );
     }
     let fields = match read_daemon_owner_fields(&external[0].1, &external[0].0) {
         Ok(fields) => fields,
-        Err(reason) => return Some(reason),
+        Err(reason) => return Some(reason.into()),
     };
     if fields.get("writer").map(String::as_str) != Some(current.as_str()) {
-        return Some(format!(
-            "freshness-daemon owner {} belongs to a different writing build",
-            external[0].0
-        ));
+        return Some(
+            format!(
+                "freshness-daemon owner {} belongs to a different writing build",
+                external[0].0
+            )
+            .into(),
+        );
     }
     let expected_token = match std::env::var(DERIVED_ADOPTION_OWNER_TOKEN_ENV) {
         Ok(value)
@@ -1008,17 +1101,23 @@ fn adoption_daemon_fence(data: &Path) -> Option<String> {
             value
         }
         _ => {
-            return Some(format!(
-                "freshness-daemon owner {} is not authorized for this derived write",
-                external[0].0
-            ));
+            return Some(
+                format!(
+                    "freshness-daemon owner {} is not authorized for this derived write",
+                    external[0].0
+                )
+                .into(),
+            );
         }
     };
     if fields.get("token").map(String::as_str) != Some(expected_token.as_str()) {
-        return Some(format!(
-            "freshness-daemon owner {} belongs to a different writing generation",
-            external[0].0
-        ));
+        return Some(
+            format!(
+                "freshness-daemon owner {} belongs to a different writing generation",
+                external[0].0
+            )
+            .into(),
+        );
     }
     None
 }
@@ -1032,7 +1131,7 @@ struct AdoptionClaim {
 }
 
 impl AdoptionClaim {
-    fn acquire(data: &Path) -> Result<Self, String> {
+    fn acquire(data: &Path) -> Result<Self, AdoptionFence> {
         if let Some(reason) = adoption_daemon_fence(data) {
             return Err(reason);
         }
@@ -1072,7 +1171,8 @@ impl AdoptionClaim {
                     return Err(format!(
                         "cannot publish derived-adoption claim {}: {error}",
                         path.display()
-                    ));
+                    )
+                    .into());
                 }
             }
         }
@@ -4258,7 +4358,51 @@ fn published_token_inventory(
         .then(|| cache.token_namespaces())
 }
 
+/// Whether the published source snapshot is sealed to the published messages.jsonl, by the identity
+/// the released-row record uses. A pass that replaced the rows and died before its snapshot, or
+/// held it, leaves them unsealed.
+fn source_snapshot_sealed(data: &Path, generation: Option<&cache::GenerationSeal>) -> bool {
+    let Some(generation) = generation else {
+        return false;
+    };
+    let seal_path = data.join(SOURCE_SNAPSHOT_SEAL_FILE);
+    read_optional_bytes(&seal_path, SOURCE_SNAPSHOT_SEAL_MAX_BYTES)
+        .ok()
+        .flatten()
+        .is_some_and(|recorded| {
+            String::from_utf8_lossy(&recorded).trim() == generation_seal_hex(generation)
+        })
+}
+
+/// Bind the published source snapshot to the published messages.jsonl. Written after the snapshot,
+/// so a kill between the two leaves a seal no later pass matches; a seal already in place costs a read.
+fn seal_source_snapshot(data: &Path) -> anyhow::Result<()> {
+    let seal_path = data.join(SOURCE_SNAPSHOT_SEAL_FILE);
+    match cache::published_generation_seal(data) {
+        Some(seal) => {
+            let hex = generation_seal_hex(&seal);
+            if regular_file_has_bytes(&seal_path, hex.as_bytes())? {
+                return Ok(());
+            }
+            cache::write_bytes_atomic(&seal_path, hex.as_bytes())
+        }
+        None => cache::remove_if_exists(&seal_path),
+    }
+}
+
+fn generation_seal_hex(seal: &cache::GenerationSeal) -> String {
+    use std::fmt::Write as _;
+
+    let mut hex = String::with_capacity(32);
+    for byte in seal {
+        let _ = write!(hex, "{byte:02x}");
+    }
+    hex
+}
+
 const SOURCE_SNAPSHOT_FILE: &str = ".source_snapshot.bin";
+const SOURCE_SNAPSHOT_SEAL_FILE: &str = ".source_snapshot.seal";
+const SOURCE_SNAPSHOT_SEAL_MAX_BYTES: u64 = 4096;
 const INGEST_PENDING_FILE: &str = ".ingest_pending.bin";
 const SOURCE_ABSENCE_FILE: &str = ".source_absence_pending";
 const HARNESS_POLICY_SNAPSHOT_FILE: &str = ".harness_prefixes.snapshot";
@@ -5091,54 +5235,85 @@ fn index_cmd(agent: &str, full: bool) -> anyhow::Result<()> {
         disclose_read_only_ownership(&format!("derived writer identity is unavailable: {reason}"));
         return Ok(());
     }
-    // A rollback journal blocks the ownership probe itself and nothing on the
-    // box would ever clear it. Reclaim it first, under the index lock the
-    // writer takes anyway, then read ownership for real.
-    let corpus = data.join("corpus.db");
-    let corpus_missing = matches!(
-        agrep_core::ingest::registry::regular_file_edge_snapshot(&corpus, 0),
-        Ok(None)
-    );
-    if !corpus_missing && hot_rollback_journal(&corpus).map_or(true, |journal| journal.is_some()) {
-        let mut journal_lock = acquire_index_lock()?;
-        let reclaimed = reclaim_cold_rollback_journal(&corpus);
-        journal_lock.release()?;
-        if let Err(detail) = reclaimed {
-            disclose_read_only_ownership(&detail);
-            return Ok(());
-        }
-    }
-    let initial_ownership = derived_write_ownership(&data);
-    let ownership_was_current = initial_ownership == DerivedWriteOwnership::Current;
-    let adoption_claim = match initial_ownership {
-        DerivedWriteOwnership::Refused(reason)
-        | DerivedWriteOwnership::PostAdoptionClobber(reason) => {
-            disclose_read_only_ownership(&reason);
-            return Ok(());
+    let wait_budget = std::env::var(DERIVED_ADOPTION_WAIT_MS_ENV)
+        .ok()
+        .and_then(|value| value.parse::<u64>().ok())
+        .map(|millis| std::time::Duration::from_millis(millis.min(180_000)));
+    let mut waiting_since = None;
+    let mut wait_on_adoption = |fence: &AdoptionFence| -> anyhow::Result<bool> {
+        let (AdoptionFence::LiveSameWriter(pid), Some(budget)) = (fence, wait_budget) else {
+            return Ok(false);
+        };
+        let started = waiting_since.get_or_insert_with(|| {
+            eprintln!(
+                "waiting for the freshness daemon to finish adopting the index (pid {pid}) ..."
+            );
+            Instant::now()
+        });
+        let remaining = budget.saturating_sub(started.elapsed());
+        anyhow::ensure!(
+            !remaining.is_zero(),
+            "freshness daemon is still adopting the index (pid {pid}); \
+             the wait budget expired, but this adoption finishes on its own; \
+             run `agrep index` again after it completes"
+        );
+        std::thread::sleep(remaining.min(std::time::Duration::from_millis(100)));
+        Ok(true)
+    };
+    let (adoption_claim, ownership_was_current) = loop {
+        // The incumbent may be replacing ownership artifacts or holding a SQLite
+        // journal; wait before probing that family or taking its index lock.
+        if wait_budget.is_some() {
+            if let Some(fence) = adoption_daemon_fence(&data) {
+                if wait_on_adoption(&fence)? {
+                    continue;
+                }
+            }
         }
-        // A foreign family may only converge under the index lock; the claim proves no
-        // live daemon holds it, and the locked section performs the successor takeover.
-        DerivedWriteOwnership::Foreign(reason) => match AdoptionClaim::acquire(&data) {
-            Ok(claim) => Some(claim),
-            Err(fence) => {
-                disclose_read_only_ownership(&format!("{reason}; {fence}"));
+        // A rollback journal blocks the ownership probe itself and nothing on the
+        // box would ever clear it. Reclaim it first, under the index lock the
+        // writer takes anyway, then read ownership for real.
+        let corpus = data.join("corpus.db");
+        let corpus_missing = matches!(
+            agrep_core::ingest::registry::regular_file_edge_snapshot(&corpus, 0),
+            Ok(None)
+        );
+        if !corpus_missing
+            && hot_rollback_journal(&corpus).map_or(true, |journal| journal.is_some())
+        {
+            let mut journal_lock = acquire_index_lock()?;
+            let reclaimed = reclaim_cold_rollback_journal(&corpus);
+            journal_lock.release()?;
+            if let Err(detail) = reclaimed {
+                disclose_read_only_ownership(&detail);
                 return Ok(());
             }
-        },
-        DerivedWriteOwnership::Adoption => match AdoptionClaim::acquire(&data) {
-            Ok(claim) => Some(claim),
-            Err(reason) => {
-                disclose_read_only_ownership(&reason);
-                return Ok(());
+        }
+        let ownership = derived_write_ownership(&data);
+        if let DerivedWriteOwnership::Refused(reason)
+        | DerivedWriteOwnership::PostAdoptionClobber(reason) = &ownership
+        {
+            disclose_read_only_ownership(reason);
+            return Ok(());
+        }
+        // Retry the exclusive claim before taking .index.lock; waiting with either
+        // lock held would prevent the incumbent from completing its publication.
+        match AdoptionClaim::acquire(&data) {
+            Ok(claim) => {
+                break (Some(claim), ownership == DerivedWriteOwnership::Current);
             }
-        },
-        DerivedWriteOwnership::Current => match AdoptionClaim::acquire(&data) {
-            Ok(claim) => Some(claim),
-            Err(reason) => {
+            Err(fence) => {
+                if wait_on_adoption(&fence)? {
+                    continue;
+                }
+                let reason = match ownership {
+                    DerivedWriteOwnership::Foreign(reason) => format!("{reason}; {fence}"),
+                    _ => fence.to_string(),
+                };
                 disclose_read_only_ownership(&reason);
                 return Ok(());
             }
-        },
+        }
     };
     let lock_path = data.join(".index.lock");
     if ownership_was_current && !full && !agrep_core::emit::on() {
@@ -5207,7 +5382,7 @@ fn index_cmd_locked(
                 return Ok(());
             }
             if let Some(reason) = adoption_daemon_fence(&data) {
-                disclose_read_only_ownership(&reason);
+                disclose_read_only_ownership(&reason.to_string());
                 return Ok(());
             }
             consume_retained_corpus_owner(&data)?;
@@ -5221,7 +5396,7 @@ fn index_cmd_locked(
                 return Ok(());
             }
             if let Some(reason) = adoption_daemon_fence(&data) {
-                disclose_read_only_ownership(&reason);
+                disclose_read_only_ownership(&reason.to_string());
                 return Ok(());
             }
             false
@@ -5381,6 +5556,8 @@ fn index_cmd_locked(
         }
         // The published generation stands as the pass that published it disclosed it; no
         // refused attempt intervened, since one leaves the pending marker that bars this lane.
+        // Its snapshot is current, whatever outran its seal (a kill before it, an older build).
+        seal_source_snapshot(&data)?;
         lap!("source-check");
         println!(
             "  unchanged since last index ({} messages); skipped ingest + writes ({:.0}ms)",
@@ -5578,10 +5755,14 @@ fn index_cmd_locked(
         expected_paths.extend(paths);
     }
     pcache.set_repair_expectations(expected_agents, expected_paths);
-    // The publication guard's own inventory, independent of the deletion machinery above so
-    // --full still converges real deletions: what the last published generation contained,
-    // or a proven-empty set when nothing was ever published.
-    if let Some(published) = published_source.as_deref() {
+    // The publication guard's own inventory, independent of the deletion machinery above so --full
+    // still converges real deletions: what the published generation contained, or a proven-empty set
+    // when nothing was published. A snapshot an unfinished publication outran inventories older rows.
+    let generation = cache::published_generation_seal(&data);
+    let published_inventory = published_source
+        .as_deref()
+        .filter(|_| pending_source.is_none() || source_snapshot_sealed(&data, generation.as_ref()));
+    if let Some(published) = published_inventory {
         let (_, paths) = ingest::registry::source_snapshot_expectations(published);
         pcache.set_published_material(paths);
         // That inventory lists only what it could read. Name the scopes it could not, so a
@@ -5595,8 +5776,8 @@ fn index_cmd_locked(
     } else if !prior_generation {
         pcache.set_published_material(HashSet::new());
     } else if pcache.decoded_last_good_base() {
-        // Publication withheld every snapshot (0.3.2 held it beside any source issue, and an
-        // `--emit-rows` pass takes none). Every Stat and token row it published was cached
+        // Publication withheld every snapshot (0.3.2 held it beside any source issue, `--emit-rows`
+        // takes none) or sealed it beside older rows. Every Stat and token row published was cached
         // first, as `published_token_inventory` relies on; whole-store rows need not have been.
         pcache.set_published_material_from_cache();
     }
@@ -5660,7 +5841,7 @@ fn index_cmd_locked(
             source_issues
                 .iter()
                 .map(|issue| (issue.agent(), Path::new(issue.path()))),
-            cache::published_generation_seal(&data),
+            generation,
         );
     }
     lap!("load-cache");
@@ -5995,6 +6176,7 @@ fn index_cmd_locked(
             &pending_path,
         )?;
         if source_published {
+            seal_source_snapshot(&data)?;
             cache::remove_if_exists(&absence_path)?;
         }
         lap!("source-publish");
@@ -6150,6 +6332,7 @@ fn index_cmd_locked(
         &pending_path,
     )?;
     if source_published {
+        seal_source_snapshot(&data)?;
         cache::remove_if_exists(&absence_path)?;
     }
     lap!("source-publish");
@@ -7801,6 +7984,77 @@ mod tests {
         let _ = std::fs::remove_dir_all(&data);
     }
 
+    #[test]
+    fn same_writer_adoption_remains_fenced_with_an_exact_busy_diagnosis() {
+        let pid = std::process::id();
+        let start = super::index_lock::current_process_start_identity().unwrap();
+        let writer = agrep_core::ingest_cache::current_cache_writer_build_id();
+        let token = "c".repeat(32);
+        let data = std::env::temp_dir().join(format!(
+            "agrep-exact-adoption-{pid}-{}",
+            std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_nanos()
+        ));
+        std::fs::create_dir_all(&data).unwrap();
+        let legacy = data.join(".indexd.lock");
+        let current = data.join(".indexd.v2.lock");
+        let raw = format!(
+            "state=derived-adoption pid={pid} start={start} writer={writer} token={token}\n"
+        );
+        std::fs::write(&legacy, &raw).unwrap();
+        std::fs::write(&current, &raw).unwrap();
+        assert_eq!(
+            super::adoption_daemon_fence(&data),
+            Some(super::AdoptionFence::LiveSameWriter(pid))
+        );
+        assert_eq!(std::fs::read_to_string(&legacy).unwrap(), raw);
+        assert_eq!(std::fs::read_to_string(&current).unwrap(), raw);
+        std::fs::write(&current, raw.replace(&token, &"d".repeat(32))).unwrap();
+        assert!(matches!(
+            super::adoption_daemon_fence(&data),
+            Some(super::AdoptionFence::Refused(_))
+        ));
+
+        std::fs::remove_file(&current).unwrap();
+        for untrusted in [
+            raw.replace(&format!("start={start}"), "start=unknown"),
+            raw.replace(&format!("pid={pid}"), &format!("pid=+{pid}")),
+            raw.replace("state=derived-adoption", "state=legacy"),
+            raw.replace(&format!("token={token}"), "token=invalid"),
+            raw.replace('\n', &format!(" pid={pid}\n")),
+            raw.replace('\n', " extra=untrusted\n"),
+            raw.replace('\n', "\n\n"),
+            raw.replace('\n', "\0\n"),
+        ] {
+            std::fs::write(&legacy, &untrusted).unwrap();
+            let reason = super::adoption_daemon_fence(&data).unwrap();
+            assert!(
+                matches!(reason, super::AdoptionFence::Refused(_)),
+                "{untrusted}: {reason}"
+            );
+            assert_eq!(std::fs::read_to_string(&legacy).unwrap(), untrusted);
+        }
+        std::fs::write(&legacy, &raw).unwrap();
+        let unknown = data.join(".indexd.v3.lock");
+        std::fs::write(&unknown, &raw).unwrap();
+        assert!(super::adoption_daemon_fence(&data)
+            .unwrap()
+            .to_string()
+            .contains("legacy or ambiguous"));
+        std::fs::remove_file(unknown).unwrap();
+        #[cfg(unix)]
+        {
+            std::os::unix::fs::symlink(&legacy, &current).unwrap();
+            assert!(matches!(
+                super::adoption_daemon_fence(&data),
+                Some(super::AdoptionFence::Refused(_))
+            ));
+        }
+        std::fs::remove_dir_all(data).unwrap();
+    }
+
     #[test]
     fn live_adoption_claim_from_different_build_blocks_fencing() {
         let data = std::env::temp_dir().join(format!(

{agrep-0.4.0 → agrep-0.4.2}/py/audit.py

@@ -1660,16 +1660,17 @@ def main(argv: list[str] | None = None) -> int:
         if not work_available("orphaned-tally join"):
             validation_complete = False
             break
-        for _key, entry in keyed_entries:
-            agent = str(entry.get("agent") or "")
-            if agent:
-                book_agents.add(agent)
+        agents_here = {str(entry.get("agent") or "") for _key, entry in keyed_entries} - {""}
         if path in seen_paths:
+            book_agents.update(agents_here)
             continue
         state, detail = _path_state(path)
         if state == "missing":
+            # A deleted store's tallies stay behind; they count here, not as that agent's evidence.
             orphan_count += 1
-        elif state == "unreadable":
+            continue
+        book_agents.update(agents_here)
+        if state == "unreadable":
             problems.append(f"cannot stat tallied source {path}: {detail}")
         else:
             agents = sorted({str(entry.get("agent") or "")