fix(reconciliation): enhance reconciliation sweep configuration and behavior

Author: Gravirei

crates/gitlawb-node/src/api/ipfs.rs

@@ -213,16 +213,33 @@ pub async fn get_by_cid(
 
 /// GET /api/v1/ipfs/pins
 ///
-/// Returns all CIDs that have been pinned to the local IPFS node from git
-/// objects received via push. Each entry includes the git SHA-256 hex, the
-/// CIDv1 string, and the timestamp when it was pinned.
+/// Returns all CIDs that have been pinned from git objects received via push.
+/// Each entry includes the git SHA-256 hex, a CIDv1 string, and the timestamp
+/// when it was pinned.  For Pinata-only rows (no local IPFS pin), the `cid`
+/// field carries `pinata_cid` so CLI consumers see a usable value.  The raw
+/// `pinata_cid` is also surfaced.
 pub async fn list_pins(State(state): State<AppState>) -> Result<Json<serde_json::Value>> {
     let pins = state
         .db
         .list_pinned_cids()
         .await
         .map_err(AppError::Internal)?;
 
+    let pins: Vec<serde_json::Value> = pins
+        .into_iter()
+        .map(|p| {
+            // Synthesize a usable CID from pinata_cid when this is a
+            // Pinata-only row (no local IPFS pin).
+            let display_cid = p.cid.clone().or_else(|| p.pinata_cid.clone());
+            serde_json::json!({
+                "sha256_hex": p.sha256_hex,
+                "cid": display_cid,
+                "pinned_at": p.pinned_at,
+                "pinata_cid": p.pinata_cid,
+            })
+        })
+        .collect();
+
     Ok(Json(serde_json::json!({
         "pins": pins,
         "count": pins.len(),

crates/gitlawb-node/src/config.rs

@@ -86,6 +86,17 @@ pub struct Config {
     #[arg(long, env = "GITLAWB_AUTO_SYNC", default_value_t = false)]
     pub auto_sync: bool,
 
+    /// Enable the periodic reconciliation sweep that re-derives pin/seal sets
+    /// and fills durability gaps.  Defaults to true; set to false to disable
+    /// the sweep even when a pin backend (IPFS/Pinata) is configured.
+    #[arg(
+        long,
+        env = "GITLAWB_RECONCILIATION_SWEEP",
+        default_value_t = true,
+        action = clap::ArgAction::Set
+    )]
+    pub reconciliation_sweep: bool,
+
     /// Irys URL for Arweave permanent anchoring.
     /// Leave empty to disable. Use https://devnet.irys.xyz for free devnet.
     #[arg(long, env = "GITLAWB_IRYS_URL", default_value = "")]

crates/gitlawb-node/src/db/mod.rs

@@ -2331,7 +2331,7 @@ impl Db {
             .into_iter()
             .map(|r| PinnedCidRecord {
                 sha256_hex: r.get("sha256_hex"),
-                cid: r.get("cid"),
+                cid: r.try_get("cid").ok(),
                 pinned_at: r.get("pinned_at"),
                 pinata_cid: r.get("pinata_cid"),
             })
@@ -3765,6 +3765,149 @@ mod migration_tests {
         // (d) Re-run: idempotent — ADD COLUMN IF NOT EXISTS must not error.
         db.migrate().await.unwrap();
     }
+
+    /// Migration v12 makes pinned_cids.cid nullable so record_pinata_cid can
+    /// create Pinata-only rows without a local IPFS CID.  This test seeds a
+    /// pre-v12 schema (cid NOT NULL, pinata_cid column exists but no
+    /// nullability change yet) with rows in each of the three states the
+    /// has_ipfs_cid / filter_ipfs_pinned_oids predicates must classify:
+    ///
+    ///   (1) cid IS NOT NULL, pinata_cid IS NULL              → has_ipfs = true
+    ///   (2) cid IS NOT NULL, cid != pinata_cid              → has_ipfs = true
+    ///   (3) cid IS NOT NULL, cid = pinata_cid (legacy)      → has_ipfs = false
+    ///
+    /// After the migration we also test that a Pinata-only INSERT (cid = NULL)
+    /// works and produces has_ipfs = false, has_pinata = true.
+    #[sqlx::test]
+    async fn migration_v12_makes_cid_nullable_and_preserves_classification(pool: sqlx::PgPool) {
+        let db = super::Db::for_testing(pool);
+
+        // Create all tables, then drop the NOT NULL constraint on cid
+        // and drop schema_migrations records to simulate a pre-v12 node.
+        db.migrate().await.unwrap();
+        sqlx::query("ALTER TABLE pinned_cids ALTER COLUMN cid SET NOT NULL")
+            .execute(&db.pool)
+            .await
+            .unwrap();
+
+        sqlx::query("DELETE FROM schema_migrations")
+            .execute(&db.pool)
+            .await
+            .unwrap();
+        for m in MIGRATIONS.iter().take_while(|m| m.version < 12) {
+            sqlx::query(
+                "INSERT INTO schema_migrations (version, name, applied_at)
+                 VALUES ($1, $2, $3)",
+            )
+            .bind(m.version)
+            .bind(m.name)
+            .bind("2026-07-01T00:00:00Z")
+            .execute(&db.pool)
+            .await
+            .unwrap();
+        }
+
+        // ── Seed legacy rows ───────────────────────────────────────────
+        let now = "2026-07-01T12:00:00Z";
+
+        // (1) Real local IPFS pin, no Pinata.
+        sqlx::query(
+            "INSERT INTO pinned_cids (sha256_hex, cid, pinned_at, pinata_cid)
+             VALUES ($1, $2, $3, $4)",
+        )
+        .bind("sha_real_only")
+        .bind("QmRealLocalCid")
+        .bind(now)
+        .bind(Option::<&str>::None)
+        .execute(&db.pool)
+        .await
+        .unwrap();
+
+        // (2) Both CIDs present and distinct.
+        sqlx::query(
+            "INSERT INTO pinned_cids (sha256_hex, cid, pinned_at, pinata_cid)
+             VALUES ($1, $2, $3, $4)",
+        )
+        .bind("sha_both_distinct")
+        .bind("QmLocalForThisBlob")
+        .bind(now)
+        .bind("QmPinataForThisBlob")
+        .execute(&db.pool)
+        .await
+        .unwrap();
+
+        // (3) Legacy row where cid was set to pinata_cid as fallback.
+        sqlx::query(
+            "INSERT INTO pinned_cids (sha256_hex, cid, pinned_at, pinata_cid)
+             VALUES ($1, $2, $3, $4)",
+        )
+        .bind("sha_legacy_fallback")
+        .bind("QmLegacyEqual")
+        .bind(now)
+        .bind("QmLegacyEqual")
+        .execute(&db.pool)
+        .await
+        .unwrap();
+
+        // ── Apply migration v12 ────────────────────────────────────────
+        db.migrate().await.unwrap();
+
+        // ── Assertions ─────────────────────────────────────────────────
+
+        // Column is now nullable.
+        let nullable: String = sqlx::query_scalar(
+            "SELECT is_nullable FROM information_schema.columns
+             WHERE table_name = 'pinned_cids' AND column_name = 'cid'",
+        )
+        .fetch_one(&db.pool)
+        .await
+        .unwrap();
+        assert_eq!(nullable, "YES", "cid must be nullable after v12");
+
+        // Classification: has_ipfs_cid.
+        assert!(
+            db.has_ipfs_cid("sha_real_only").await.unwrap(),
+            "real local IPFS CID must be classified as pinned"
+        );
+        assert!(
+            db.has_ipfs_cid("sha_both_distinct").await.unwrap(),
+            "distinct local CID must be classified as pinned"
+        );
+        assert!(
+            !db.has_ipfs_cid("sha_legacy_fallback").await.unwrap(),
+            "legacy equal-cid row must NOT be classified as having an IPFS CID"
+        );
+
+        // has_pinata_cid.
+        assert!(
+            !db.has_pinata_cid("sha_real_only").await.unwrap(),
+            "no pinata_cid means has_pinata = false"
+        );
+        assert!(
+            db.has_pinata_cid("sha_both_distinct").await.unwrap(),
+            "non-null pinata_cid means has_pinata = true"
+        );
+        assert!(
+            db.has_pinata_cid("sha_legacy_fallback").await.unwrap(),
+            "non-null pinata_cid means has_pinata = true (legacy row)"
+        );
+
+        // ── Pinata-only INSERT (new post-v12 row) ──────────────────────
+        db.record_pinata_cid("sha_pinata_only", "QmPinataOnly")
+            .await
+            .unwrap();
+        assert!(
+            !db.has_ipfs_cid("sha_pinata_only").await.unwrap(),
+            "Pinata-only row must NOT be classified as having a local IPFS CID"
+        );
+        assert!(
+            db.has_pinata_cid("sha_pinata_only").await.unwrap(),
+            "Pinata-only row must have has_pinata = true"
+        );
+
+        // ── Idempotent re-run ──────────────────────────────────────────
+        db.migrate().await.unwrap();
+    }
 }
 
 #[cfg(test)]

crates/gitlawb-node/src/git/mod.rs

@@ -191,7 +191,7 @@ impl GitCommand {
         // is set while we hold the lock, the sweep cannot drain the
         // registry until we release it.
         if let Some(ref ctx) = ctx {
-            let mut registry = ctx.registry.lock().unwrap();
+            let mut registry = ctx.registry.lock().unwrap_or_else(|e| e.into_inner());
             if ctx.canceled.load(Ordering::SeqCst) {
                 // Canceled after spawn: kill the whole process group (not
                 // just the immediate child) and wait to avoid zombies.
@@ -226,7 +226,11 @@ struct PgidGuard {
 impl Drop for PgidGuard {
     fn drop(&mut self) {
         if let (Some(pgid), Some(ref ctx)) = (self.pgid, &self.ctx) {
-            ctx.registry.lock().unwrap().remove(&pgid);
+            let _ = ctx
+                .registry
+                .lock()
+                .unwrap_or_else(|e| e.into_inner())
+                .remove(&pgid);
         }
     }
 }

crates/gitlawb-node/src/git/store.rs

@@ -66,9 +66,8 @@ pub fn list_refs(repo_path: &Path) -> Result<Vec<(String, String)>> {
 /// Read the current HEAD commit hash of a repository.
 /// Returns None if the repo is empty (no commits yet).
 pub fn head_commit(repo_path: &Path) -> Result<Option<String>> {
-    let output = Command::new("git")
+    let output = crate::git::GitCommand::new(repo_path)
         .args(["rev-parse", "--verify", "HEAD"])
-        .current_dir(repo_path)
         .output()
         .context("failed to run git rev-parse")?;