From 71182b70d50bcef8103b6d5051804352b9fcb27e Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Wed, 14 Oct 2026 09:46:16 +0900 Subject: [PATCH 1/6] =?UTF-8?q?fix(sync):=20v0.3.1=20=EB=A6=AC=EB=B7=B0=20?= =?UTF-8?q?=ED=9B=84=EC=86=8D=203=EA=B1=B4=C2=B7=EB=A6=B4=EB=A6=AC?= =?UTF-8?q?=EC=8A=A4=20=EB=AC=B8=EC=84=9C=20npx=20=ED=95=A8=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - legacy 수락이 충돌·용량 부족으로 끝나면 '보류했습니다' 대신 실제 결과 안내 - 축출 때 바인딩 정리를 Proposal 후보로 한정(Held·Conflict 는 불변 vid 검사용으로 유지) - review 도중 더 새 변경으로 퇴역했거나 충돌로 바뀐 후보를 말없이 건너뛰지 않고 안내 - RELEASING: npm 설치 확인은 ./node_modules/.bin/kc 로(npx kc 는 설치 실패 시 남의 kc 패키지 실행) Refs DCO-43 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AcJNLuNvFR9uo8NsqLVCj6 --- crates/kc-cli/locales/de.toml | 1 + crates/kc-cli/locales/es.toml | 1 + crates/kc-cli/locales/fr.toml | 1 + crates/kc-cli/locales/ja.toml | 1 + crates/kc-cli/locales/ko.toml | 1 + crates/kc-cli/locales/zh-Hans.toml | 1 + crates/kc-cli/locales/zh-Hant.toml | 1 + crates/kc-cli/src/sync/actions.rs | 34 +++++-- crates/kc-cli/src/sync/mod.rs | 6 +- crates/kc-cli/src/sync/receive.rs | 18 +++- crates/kc-cli/tests/common/mod.rs | 19 +++- crates/kc-cli/tests/sync.rs | 138 +++++++++++++++++++++++++++++ docs/RELEASING.md | 6 +- 13 files changed, 215 insertions(+), 13 deletions(-) diff --git a/crates/kc-cli/locales/de.toml b/crates/kc-cli/locales/de.toml index 6ceb88b..d88d2f1 100644 --- a/crates/kc-cli/locales/de.toml +++ b/crates/kc-cli/locales/de.toml @@ -501,6 +501,7 @@ "Sync item held; run `kc sync review`." = "Synchronisierungselement zurückgehalten; `kc sync review` ausführen." "{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} steht im Konflikt; zuerst mit `kc sync resolve {name}` auflösen." "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`." = "{name} wurde inzwischen auf diesem Gerät geändert und steht jetzt im Konflikt; mit `kc sync resolve {name}` auflösen." +"{name} from {peer} was replaced by a newer change; run `kc sync review` again." = "{name} von {peer} wurde durch eine neuere Änderung ersetzt; `kc sync review` erneut ausführen." "removed from sync" = "aus der Synchronisierung entfernt" "hasn't answered the sync handshake yet" = "hat auf den Sync-Handshake noch nicht geantwortet" "paused after too many changes" = "nach zu vielen Änderungen pausiert" diff --git a/crates/kc-cli/locales/es.toml b/crates/kc-cli/locales/es.toml index e92fd2c..a874a6a 100644 --- a/crates/kc-cli/locales/es.toml +++ b/crates/kc-cli/locales/es.toml @@ -501,6 +501,7 @@ "Sync item held; run `kc sync review`." = "Elemento de sincronización retenido; ejecuta `kc sync review`." "{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} está en conflicto; resuélvelo primero con `kc sync resolve {name}`." "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`." = "{name} cambió en este dispositivo mientras tanto y ahora está en conflicto; resuélvelo con `kc sync resolve {name}`." +"{name} from {peer} was replaced by a newer change; run `kc sync review` again." = "{name} de {peer} fue reemplazado por un cambio más reciente; ejecuta `kc sync review` de nuevo." "removed from sync" = "quitado de la sincronización" "hasn't answered the sync handshake yet" = "aún no ha respondido al saludo de sincronización" "paused after too many changes" = "en pausa tras demasiados cambios" diff --git a/crates/kc-cli/locales/fr.toml b/crates/kc-cli/locales/fr.toml index 8943b10..c1a5659 100644 --- a/crates/kc-cli/locales/fr.toml +++ b/crates/kc-cli/locales/fr.toml @@ -501,6 +501,7 @@ "Sync item held; run `kc sync review`." = "Élément de synchronisation en attente ; exécutez `kc sync review`." "{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} est en conflit ; résolvez-le d’abord avec `kc sync resolve {name}`." "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`." = "{name} a été modifié entre-temps sur cet appareil et est maintenant en conflit ; résolvez-le avec `kc sync resolve {name}`." +"{name} from {peer} was replaced by a newer change; run `kc sync review` again." = "{name} depuis {peer} a été remplacé par une modification plus récente ; exécutez à nouveau `kc sync review`." "removed from sync" = "retiré de la synchronisation" "hasn't answered the sync handshake yet" = "n’a pas encore répondu à la négociation de synchronisation" "paused after too many changes" = "en pause après trop de modifications" diff --git a/crates/kc-cli/locales/ja.toml b/crates/kc-cli/locales/ja.toml index d964252..3bca45b 100644 --- a/crates/kc-cli/locales/ja.toml +++ b/crates/kc-cli/locales/ja.toml @@ -501,6 +501,7 @@ "Sync item held; run `kc sync review`." = "同期項目を保留しました。`kc sync review`を実行してください。" "{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} は競合中です。先に `kc sync resolve {name}` で解決してください。" "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`." = "その間にこのデバイスで {name} が変更されたため、競合になりました。`kc sync resolve {name}` で解決してください。" +"{name} from {peer} was replaced by a newer change; run `kc sync review` again." = "{peer} からの {name} の変更は、より新しい変更に置き換えられました。`kc sync review` をもう一度実行してください。" "removed from sync" = "同期から外した" "hasn't answered the sync handshake yet" = "同期ハンドシェイクの応答待ち" "paused after too many changes" = "変更が多すぎるため一時停止中" diff --git a/crates/kc-cli/locales/ko.toml b/crates/kc-cli/locales/ko.toml index ed53b24..3a6dd69 100644 --- a/crates/kc-cli/locales/ko.toml +++ b/crates/kc-cli/locales/ko.toml @@ -501,6 +501,7 @@ "Sync item held; run `kc sync review`." = "동기화 항목을 보류했습니다. `kc sync review`를 실행하세요." "{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 항목이 충돌 중입니다. 먼저 `kc sync resolve {name}`로 해결하세요." "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`." = "그사이 이 기기에서 {name} 항목이 바뀌어 충돌 상태가 되었습니다. `kc sync resolve {name}`로 해결하세요." +"{name} from {peer} was replaced by a newer change; run `kc sync review` again." = "{peer}에서 온 {name} 변경은 더 최근 변경으로 대체되었습니다. `kc sync review`를 다시 실행하세요." "removed from sync" = "동기화에서 뺌" "hasn't answered the sync handshake yet" = "아직 동기화 연결 응답 없음" "paused after too many changes" = "변경이 너무 많아 일시 중지됨" diff --git a/crates/kc-cli/locales/zh-Hans.toml b/crates/kc-cli/locales/zh-Hans.toml index d369a53..8dd8360 100644 --- a/crates/kc-cli/locales/zh-Hans.toml +++ b/crates/kc-cli/locales/zh-Hans.toml @@ -501,6 +501,7 @@ "Sync item held; run `kc sync review`." = "同步项目已保留;请运行 `kc sync review`。" "{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 存在冲突,请先用 `kc sync resolve {name}` 解决。" "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`." = "{name} 在此期间已在本设备上更改,现已成为冲突,请用 `kc sync resolve {name}` 解决。" +"{name} from {peer} was replaced by a newer change; run `kc sync review` again." = "来自 {peer} 的 {name} 更改已被更新的更改取代,请再次运行 `kc sync review`。" "removed from sync" = "已移出同步" "hasn't answered the sync handshake yet" = "尚未回应同步握手" "paused after too many changes" = "因更改过多已暂停" diff --git a/crates/kc-cli/locales/zh-Hant.toml b/crates/kc-cli/locales/zh-Hant.toml index ff1cbcb..3928108 100644 --- a/crates/kc-cli/locales/zh-Hant.toml +++ b/crates/kc-cli/locales/zh-Hant.toml @@ -501,6 +501,7 @@ "Sync item held; run `kc sync review`." = "同步項目已保留;請執行 `kc sync review`。" "{name} is in conflict; settle it with `kc sync resolve {name}` first." = "{name} 有衝突,請先用 `kc sync resolve {name}` 解決。" "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`." = "{name} 在此期間已在本裝置上變更,現已成為衝突,請用 `kc sync resolve {name}` 解決。" +"{name} from {peer} was replaced by a newer change; run `kc sync review` again." = "來自 {peer} 的 {name} 變更已被更新的變更取代,請再次執行 `kc sync review`。" "removed from sync" = "已移出同步" "hasn't answered the sync handshake yet" = "尚未回應同步交握" "paused after too many changes" = "因變更過多已暫停" diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs index dff5a5d..169437e 100644 --- a/crates/kc-cli/src/sync/actions.rs +++ b/crates/kc-cli/src/sync/actions.rs @@ -447,19 +447,39 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { } } } + // Accepting one candidate clears the item's other candidates. + let mut applied = std::collections::BTreeSet::new(); for c in accepts { if s.frozen { break; } - if let Some(current) = s.candidates.get(&c.version.slot).cloned() - && current.category != CandidateKind::Conflict - { - match transaction::accept(ctx, &mut s, ¤t)? { - Accepted::Applied => done.push(tr!( - "Accepted {name} from {peer}.", + // The candidate may have changed since it was listed: retired as superseded by a + // newer change from the same peer, or turned into a conflict. + let Some(current) = s.candidates.get(&c.version.slot).cloned() else { + if !applied.contains(&c.version.name) { + done.push(tr!( + "{name} from {peer} was replaced by a newer change; run `kc sync review` again.", name = c.version.name, peer = label(ctx, &c.peer)? - )), + )); + } + continue; + }; + if current.category == CandidateKind::Conflict { + done.push(tr!( + "{name} is in conflict; settle it with `kc sync resolve {name}` first.", + name = c.version.name + )); + } else { + match transaction::accept(ctx, &mut s, ¤t)? { + Accepted::Applied => { + done.push(tr!( + "Accepted {name} from {peer}.", + name = c.version.name, + peer = label(ctx, &c.peer)? + )); + applied.insert(c.version.name.clone()); + } Accepted::Conflict => done.push(tr!( "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`.", name = c.version.name diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index d728948..6e2d66b 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -236,8 +236,10 @@ fn reserve_keeping( s.candidates.retain(|_, c| c.version.slot != victim); for c in evicted { s.gc.insert(c.base_record); - // An invalid binding's record belongs to the legitimate vid. - if !c.invalid_binding { + // Only a proposal's binding goes with it: held and conflict bindings stay + // for the immutable-vid check, as in retire_superseded. An invalid + // binding's record belongs to the legitimate vid. + if c.category == CandidateKind::Proposal && !c.invalid_binding { forget_binding(s, &c.version.name, c.version.vid); } } diff --git a/crates/kc-cli/src/sync/receive.rs b/crates/kc-cli/src/sync/receive.rs index 819c9a3..9751adb 100644 --- a/crates/kc-cli/src/sync/receive.rs +++ b/crates/kc-cli/src/sync/receive.rs @@ -775,9 +775,23 @@ pub(crate) fn legacy( return Err(error); } let c = s.candidates[&slot].clone(); - if transaction::accept(ctx, &mut s, &c)? == transaction::Accepted::Applied { - return Ok(Some(kc_proto::ItemStatus::Stored)); + let line = match transaction::accept(ctx, &mut s, &c)? { + transaction::Accepted::Applied => return Ok(Some(kc_proto::ItemStatus::Stored)), + transaction::Accepted::Conflict => Some(tr!( + "{name} changed on this device meanwhile and is now a conflict; settle it with `kc sync resolve {name}`.", + name = name + )), + transaction::Accepted::Full => Some(tr!( + "Sync storage is full; review pending items before retrying." + )), + // accept() already said which conflict must be settled first. + transaction::Accepted::Unsettled => None, + }; + s.cleanup(ctx)?; + if let Some(line) = line { + crate::commands::say!(ctx, "{line}"); } + return Ok(Some(kc_proto::ItemStatus::SkippedConflict)); } s.cleanup(ctx)?; crate::commands::say!(ctx, "{}", tr!("Sync item held; run `kc sync review`.")); diff --git a/crates/kc-cli/tests/common/mod.rs b/crates/kc-cli/tests/common/mod.rs index f9526c7..0d8ba45 100644 --- a/crates/kc-cli/tests/common/mod.rs +++ b/crates/kc-cli/tests/common/mod.rs @@ -10,7 +10,7 @@ use std::collections::VecDeque; use std::ffi::OsString; use std::io::{self, Read, Write}; -use std::path::PathBuf; +use std::path::{Path, PathBuf}; use std::process::Command; use std::time::Duration; @@ -191,8 +191,13 @@ pub struct Run { pub local_auth: VecDeque, pub env: Vec<(String, String)>, pub code_tx: Option>, + /// Runs once at the first local confirmation, standing in for another process that + /// changes the device meanwhile (gets the device's store and config dir). + pub on_local_confirm: Option, } +pub type LocalConfirmHook = Box; + impl Run { /// An agent: piped stdin and `CLAUDECODE=1`. pub fn agent() -> Run { @@ -204,6 +209,7 @@ impl Run { local_auth: VecDeque::new(), env: vec![("CLAUDECODE".into(), "1".into())], code_tx: None, + on_local_confirm: None, } } @@ -217,6 +223,7 @@ impl Run { local_auth: VecDeque::new(), env: Vec::new(), code_tx: None, + on_local_confirm: None, } } @@ -234,6 +241,11 @@ impl Run { self.code_tx = Some(tx); self } + + pub fn on_local_confirm(mut self, hook: impl FnOnce(Store, &Path) + Send + 'static) -> Run { + self.on_local_confirm = Some(Box::new(hook)); + self + } } #[derive(Debug)] @@ -272,6 +284,7 @@ struct TestHost<'d, N: Net> { stdout_terminal: bool, env: Vec<(String, String)>, local_auth: VecDeque, + on_local_confirm: Option, } impl Host for TestHost<'_, N> { @@ -286,6 +299,9 @@ impl Host for TestHost<'_, N> { self.console .prompts .push(format!("local confirmation: {reason}")); + if let Some(hook) = self.on_local_confirm.take() { + hook(self.device.store(), self.device.dir.path()); + } self.local_auth.pop_front().unwrap_or_else(|| { LocalAuthOutcome::Unavailable("no scripted local confirmation".into()) }) @@ -425,6 +441,7 @@ impl Device { stdout_terminal: run.stdout_terminal, env, local_auth: run.local_auth, + on_local_confirm: run.on_local_confirm, }; let argv = std::iter::once("kc") .chain(args.iter().copied()) diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs index f25dd72..28d2946 100644 --- a/crates/kc-cli/tests/sync.rs +++ b/crates/kc-cli/tests/sync.rs @@ -2158,3 +2158,141 @@ async fn resolve_at_full_capacity_reports_storage_full_instead_of_resolved() { ); assert_eq!(state(&b)["items"]["KEY"]["conflict"], true); } +#[tokio::test] +async fn legacy_accept_turned_conflict_reports_the_conflict_not_held() { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.store() + .set( + "KEY", + b"fake-legacy-terminal", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + a.run(&["send", "KEY", "--to", "bravo"], Run::agent()) + .await + .expect(0); + // A local edit lands while the overwrite waits for local confirmation. + let run = human(vec![Answer::Yes]).on_local_confirm(|store, _| { + store + .set( + "KEY", + b"fake-intervening-local", + kc_store::ItemKind::Text, + kc_store::Origin::Local, + ) + .unwrap(); + }); + let out = b.run(&["inbox", "--on-conflict", "overwrite"], run).await; + assert!( + out.stderr + .contains("KEY changed on this device meanwhile and is now a conflict"), + "{}", + out.stderr + ); + assert!(!out.stderr.contains("Sync item held"), "{}", out.stderr); + assert_eq!(b.value("KEY").unwrap(), b"fake-intervening-local"); + assert_eq!(state(&b)["items"]["KEY"]["conflict"], true); +} +#[tokio::test] +async fn evicted_held_candidate_keeps_its_binding() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let held = Vid::random(); + post( + &a, + &b, + &relay, + change_message("KEY", held, head(&b), b"fake-held"), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert!(holds_candidate(&state(&b), held)); + // Fill the budget with checkpoints so the next snapshot can only evict the held slot. + let mut s = state(&b); + let used = s["slots"].as_object().unwrap().len(); + for n in used..16 { + let slot = format!("sync/kg/test-{n}"); + b.store().set_internal(&slot, b"fake-pinned").unwrap(); + s["slots"][slot] = "Checkpoint".into(); + } + save_state(&b, &s); + b.set("LOCAL", b"fake-local").await; + b.run(&["sync", "add", "LOCAL", "--peers", "alpha"], human(vec![])) + .await + .expect(8); + assert!(!holds_candidate(&state(&b), held)); + assert!( + b.store() + .get_internal(&fp_slot("KEY", held)) + .unwrap() + .is_some() + ); +} +async fn review_with_candidate_changed_meanwhile( + change: impl FnOnce(&mut Value) + Send + 'static, +) -> common::Output { + let (a, b, _) = devices().await; + enroll(&a, &b).await; + a.set("KEY", b"fake-incoming").await; + pump(&a, &b).await; + assert_eq!(state(&b)["candidates"].as_object().unwrap().len(), 1); + // Another process changes the candidate while review waits for local confirmation. + let run = human(vec![Answer::Select(0)]).on_local_confirm(move |_, dir| { + let path = dir.join("sync.json"); + let mut s: Value = serde_json::from_slice(&std::fs::read(&path).unwrap()).unwrap(); + change(&mut s); + std::fs::write(&path, serde_json::to_vec_pretty(&s).unwrap()).unwrap(); + }); + let out = b.run(&["sync", "review"], run).await; + assert!(!out.stderr.contains("Accepted KEY"), "{}", out.stderr); + assert_eq!(b.value("KEY").unwrap(), b"fake-initial-secret"); + out +} +#[tokio::test] +async fn review_reports_accepted_candidate_retired_meanwhile() { + let out = review_with_candidate_changed_meanwhile(|s| { + let slot = s["candidates"] + .as_object() + .unwrap() + .keys() + .next() + .unwrap() + .clone(); + s["candidates"].as_object_mut().unwrap().remove(&slot); + s["slots"].as_object_mut().unwrap().remove(&slot); + }) + .await; + assert!( + out.stderr + .contains("KEY from alpha was replaced by a newer change; run `kc sync review` again."), + "{}", + out.stderr + ); +} +#[tokio::test] +async fn review_reports_accepted_candidate_turned_conflict_meanwhile() { + let out = review_with_candidate_changed_meanwhile(|s| { + let slots = s["candidates"] + .as_object() + .unwrap() + .keys() + .cloned() + .collect::>(); + for slot in slots { + s["candidates"][&slot]["category"] = "conflict".into(); + s["slots"][&slot] = "ConflictCandidate".into(); + } + s["items"]["KEY"]["conflict"] = true.into(); + }) + .await; + assert_eq!( + out.stderr + .matches("KEY is in conflict; settle it with `kc sync resolve KEY` first.") + .count(), + 1, + "{}", + out.stderr + ); +} diff --git a/docs/RELEASING.md b/docs/RELEASING.md index c5c7879..1bf4304 100644 --- a/docs/RELEASING.md +++ b/docs/RELEASING.md @@ -22,7 +22,11 @@ header has its own options and environment variables. 5. Check what people get: - `brew install dcode-co/tap/kc` (or `brew upgrade kc`), then `kc --version` - `npm install 1pass-keychain@` in an empty directory, then - `npx kc --version` and `KC_LANG=ko npx kc --help` + `./node_modules/.bin/kc --version` and + `KC_LANG=ko ./node_modules/.bin/kc --help`. Not `npx kc`: if the install + failed, npx fetches and runs the unrelated npm package named `kc`. Right + after publishing, the install can fail with `ETARGET` for a few minutes; + retry with `--prefer-online`. ## npm From aa967eff560863ea7f293e351e219d923c52c8b3 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Wed, 14 Oct 2026 09:56:42 +0900 Subject: [PATCH 2/6] =?UTF-8?q?fix(sync):=20known=20=EC=83=81=ED=95=9C?= =?UTF-8?q?=EC=97=90=EC=84=9C=20=EB=B0=80=EB=A0=A4=EB=82=9C=20vid=20?= =?UTF-8?q?=EC=9D=98=20=EB=B0=94=EC=9D=B8=EB=94=A9=20=EB=A0=88=EC=BD=94?= =?UTF-8?q?=EB=93=9C=20=EC=A0=95=EB=A6=AC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - known 을 자르는 모든 지점을 trim_known 하나로 모으고, 밀려난 vid 가 head·lineage·versions·후보 어디서도 참조되지 않으면 fp 레코드를 gc - Transition::Applied 분기에 빠져 있던 known 상한 처리 추가 - 후보 제거 경로(축출·퇴역·clear_candidates·거절)에서 known 밖 vid 의 레코드 수거 Refs DCO-43 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AcJNLuNvFR9uo8NsqLVCj6 --- crates/kc-cli/src/sync/actions.rs | 1 + crates/kc-cli/src/sync/mod.rs | 46 ++++++++++++++--- crates/kc-cli/src/sync/receive.rs | 11 ++-- crates/kc-cli/src/sync/transaction.rs | 12 ++--- crates/kc-cli/tests/sync.rs | 73 +++++++++++++++++++++++++++ 5 files changed, 121 insertions(+), 22 deletions(-) diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs index 169437e..a1002d2 100644 --- a/crates/kc-cli/src/sync/actions.rs +++ b/crates/kc-cli/src/sync/actions.rs @@ -423,6 +423,7 @@ pub(crate) fn review(ctx: &mut Ctx<'_, H>) -> Result { reject_offer(&mut s, delivery, ctx.host.now()); forget_binding(&mut s, &c.version.name, c.version.vid); } else { + drop_binding(&mut s, &c.version.name, c.version.vid); s.receipts.insert( delivery, ( diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index 6e2d66b..7f44b99 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -237,10 +237,12 @@ fn reserve_keeping( for c in evicted { s.gc.insert(c.base_record); // Only a proposal's binding goes with it: held and conflict bindings stay - // for the immutable-vid check, as in retire_superseded. An invalid - // binding's record belongs to the legitimate vid. + // for the immutable-vid check while known, as in retire_superseded. An + // invalid binding's record belongs to the legitimate vid. if c.category == CandidateKind::Proposal && !c.invalid_binding { forget_binding(s, &c.version.name, c.version.vid); + } else { + drop_binding(s, &c.version.name, c.version.vid); } } s.slots.remove(&victim); @@ -254,15 +256,20 @@ fn reserve_keeping( } } } -/// Drops a dropped proposal's vid binding (`sync/fp/...` record, unbound entry, known vid) -/// unless the head, a version or another candidate still refers to it. -fn forget_binding(s: &mut State, name: &str, vid: Vid) { - let referenced = s.items.get(name).is_some_and(|i| i.head == vid) +/// Whether the head, lineage, a version or a candidate still refers to this vid binding. +fn binding_referenced(s: &State, name: &str, vid: Vid) -> bool { + s.items + .get(name) + .is_some_and(|i| i.head == vid || i.lineage.contains(&vid)) || s.versions.values().any(|v| v.name == name && v.vid == vid) || s.candidates .values() - .any(|other| other.version.name == name && other.version.vid == vid); - if referenced { + .any(|other| other.version.name == name && other.version.vid == vid) +} +/// Drops a dropped proposal's vid binding (`sync/fp/...` record, unbound entry, known vid) +/// unless something else still refers to it. +fn forget_binding(s: &mut State, name: &str, vid: Vid) { + if binding_referenced(s, name, vid) { return; } s.unbound.remove(&format!("{}:{}", name, vid_key(vid))); @@ -271,6 +278,29 @@ fn forget_binding(s: &mut State, name: &str, vid: Vid) { } s.gc.insert(record_slot(name, vid)); } +/// Drops a vid binding once it has left the item's known cache and nothing else refers to +/// it, so neither the known cap nor removed candidates leave records behind. +fn drop_binding(s: &mut State, name: &str, vid: Vid) { + if !s.items.get(name).is_some_and(|i| i.known.contains(&vid)) { + forget_binding(s, name, vid); + } +} +/// Caps the item's known cache, keeping the head, and drops the bindings that fall out. +fn trim_known(s: &mut State, name: &str) { + let Some(item) = s.items.get_mut(name) else { + return; + }; + let mut dropped = Vec::new(); + while item.known.len() > kc_sync::MAX_KNOWN { + let Some(index) = item.known.iter().position(|vid| *vid != item.head) else { + break; + }; + dropped.push(item.known.remove(index)); + } + for vid in dropped { + drop_binding(s, name, vid); + } +} /// A rejected offer stays blocked while its sender keeps retrying. const REJECTED_OFFER_TTL: i64 = kc_wire::limits::INBOX_IDLE_DELETE_DAYS as i64 * 86400; diff --git a/crates/kc-cli/src/sync/receive.rs b/crates/kc-cli/src/sync/receive.rs index 9751adb..f2daab2 100644 --- a/crates/kc-cli/src/sync/receive.rs +++ b/crates/kc-cli/src/sync/receive.rs @@ -508,6 +508,7 @@ fn change_received( if !item.known.contains(&c.new_vid) { item.known.push(c.new_vid); } + trim_known(s, name); } Transition::Unchanged => {} // No verified approval is ever constructed in Phase 1. @@ -678,15 +679,11 @@ pub(super) fn store_candidate( if !retire && !invalid_binding && let Some(item) = s.items.get_mut(&v.name) + && !item.known.contains(&v.vid) { - if !item.known.contains(&v.vid) { - item.known.push(v.vid); - } - while item.known.len() > 256 { - let index = item.known.iter().position(|vid| *vid != item.head).unwrap(); - item.known.remove(index); - } + item.known.push(v.vid); } + trim_known(s, &v.name); let key = v.slot.clone(); s.candidates.insert( key, diff --git a/crates/kc-cli/src/sync/transaction.rs b/crates/kc-cli/src/sync/transaction.rs index 4785e6a..4223686 100644 --- a/crates/kc-cli/src/sync/transaction.rs +++ b/crates/kc-cli/src/sync/transaction.rs @@ -161,12 +161,10 @@ fn finish_local( if !item.known.contains(&v.vid) { item.known.push(v.vid); } - if item.known.len() > 256 { - item.known.remove(0); - } if clear { item.conflict = false; } + trim_known(s, &r.name); s.versions.insert(vid_key(v.vid), v.clone()); s.latest_local.insert(r.name.clone(), v.vid); for target in &r.targets { @@ -200,6 +198,7 @@ pub(super) fn clear_candidates(s: &mut State, name: &str) { if let Some(c) = s.candidates.remove(&key) { release(s, &c.version.slot); s.gc.insert(c.base_record); + drop_binding(s, name, c.version.vid); } } } @@ -568,9 +567,6 @@ fn finish_remote( if !known.contains(&c.version.vid) { known.push(c.version.vid); } - if known.len() > 256 { - known.remove(0); - } s.items.insert( name.clone(), Item { @@ -583,6 +579,7 @@ fn finish_remote( conflict: false, }, ); + trim_known(s, name); if proposal { let registration = s.generations.accept(name, PeerId(c.peer.clone())); queue( @@ -691,7 +688,8 @@ pub(super) fn retire_superseded(s: &mut State, now: i64) { if let Some(old) = s.candidates.remove(&key) { release(s, &old.version.slot); s.gc.insert(old.base_record); - // The vid binding stays in known for the immutable-vid check. Held was already + drop_binding(s, &old.version.name, old.version.vid); + // The vid binding stays while in known for the immutable-vid check. Held was already // acknowledged, so no Rejected ACK is sent; the receipt stops a late duplicate. s.receipts.insert( delivery_key( diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs index 28d2946..9703737 100644 --- a/crates/kc-cli/tests/sync.rs +++ b/crates/kc-cli/tests/sync.rs @@ -2296,3 +2296,76 @@ async fn review_reports_accepted_candidate_turned_conflict_meanwhile() { out.stderr ); } +#[tokio::test] +async fn known_cap_drops_unreferenced_bindings_and_evicted_held_after_it_left_known() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let held = Vid::random(); + post( + &a, + &b, + &relay, + change_message("KEY", held, head(&b), b"fake-held"), + ) + .await; + b.run(&["inbox"], Run::agent()).await.expect(8); + assert!(holds_candidate(&state(&b), held)); + // Preload known past the cap: a lineage vid and the held vid sit first, then fillers. + let mut s = state(&b); + let head = head(&b); + let record = b + .store() + .get_internal(&fp_slot("KEY", head)) + .unwrap() + .unwrap(); + let in_lineage = Vid::random(); + let fillers = (0..256).map(|_| Vid::random()).collect::>(); + for vid in std::iter::once(&in_lineage).chain(&fillers) { + b.store() + .set_internal(&fp_slot("KEY", *vid), record.as_bytes()) + .unwrap(); + } + let mut known = vec![in_lineage, held]; + known.extend(&fillers); + known.push(head); + s["items"]["KEY"]["known"] = serde_json::to_value(&known).unwrap(); + s["items"]["KEY"]["lineage"] + .as_array_mut() + .unwrap() + .insert(0, serde_json::to_value(in_lineage).unwrap()); + save_state(&b, &s); + // A local change adds one more vid, so four fall out of known. + b.set("KEY", b"fake-local-change").await; + let s = state(&b); + let lineage: Vec = serde_json::from_value(s["items"]["KEY"]["lineage"].clone()).unwrap(); + assert!(lineage.contains(&in_lineage)); + let has = |vid: Vid| { + b.store() + .get_internal(&fp_slot("KEY", vid)) + .unwrap() + .is_some() + }; + assert!(!has(fillers[0]) && !has(fillers[1])); + assert!(has(in_lineage) && has(held) && has(fillers[2]) && has(head)); + let known: Vec = serde_json::from_value(s["items"]["KEY"]["known"].clone()).unwrap(); + assert_eq!(known.len(), 256); + for vid in [in_lineage, held, fillers[0], fillers[1]] { + assert!(!known.contains(&vid)); + } + assert!(holds_candidate(&s, held)); + // Evicting the held candidate now that its vid left known deletes its binding. + let mut s = state(&b); + let used = s["slots"].as_object().unwrap().len(); + for n in used..16 { + let slot = format!("sync/kg/test-{n}"); + b.store().set_internal(&slot, b"fake-pinned").unwrap(); + s["slots"][slot] = "Checkpoint".into(); + } + save_state(&b, &s); + b.set("LOCAL", b"fake-local").await; + b.run(&["sync", "add", "LOCAL", "--peers", "alpha"], human(vec![])) + .await + .expect(8); + assert!(!holds_candidate(&state(&b), held)); + assert!(!has(held)); +} From c161fa3a884415b83e912feb5c4f96a7828e2ad9 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Wed, 14 Oct 2026 10:06:12 +0900 Subject: [PATCH 3/6] =?UTF-8?q?fix(sync):=20fp=20=EB=A0=88=EC=BD=94?= =?UTF-8?q?=EB=93=9C=20=EC=82=AD=EC=A0=9C=20=EA=B2=8C=EC=9D=B4=ED=8A=B8?= =?UTF-8?q?=EC=99=80=20unbind=5Fwatch=20=EB=A1=9C=20=EB=B0=94=EC=9D=B8?= =?UTF-8?q?=EB=94=A9=20=EC=A0=95=EB=A6=AC=EB=A5=BC=20=EA=B5=AC=EC=A1=B0?= =?UTF-8?q?=ED=99=94?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - cleanup 이 gc 큐의 fp 레코드를 지우기 직전 head·lineage·known·versions·후보 참조를 다시 확인 - 참조 때문에 남긴 known 밖 vid 는 unbind_watch 에 두고 cleanup 마다 재확인해 고아가 되면 수거 - 같은 review 에서 거절한 vid 가 수락한 lineage 에 들어가도 레코드 보존 Refs DCO-43 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AcJNLuNvFR9uo8NsqLVCj6 --- crates/kc-cli/src/sync/mod.rs | 29 ++++++++++++-- crates/kc-cli/src/sync/state.rs | 42 +++++++++++++------ crates/kc-cli/tests/sync.rs | 71 ++++++++++++++++++++++++++++++++- 3 files changed, 126 insertions(+), 16 deletions(-) diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index 7f44b99..1fd7b5f 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -266,13 +266,26 @@ fn binding_referenced(s: &State, name: &str, vid: Vid) -> bool { .values() .any(|other| other.version.name == name && other.version.vid == vid) } +fn in_known(s: &State, name: &str, vid: Vid) -> bool { + s.items.get(name).is_some_and(|i| i.known.contains(&vid)) +} +/// The `name:vid` key of `unbound` and `unbind_watch`. +fn binding_key(name: &str, vid: Vid) -> String { + format!("{}:{}", name, vid_key(vid)) +} /// Drops a dropped proposal's vid binding (`sync/fp/...` record, unbound entry, known vid) -/// unless something else still refers to it. +/// unless something else still refers to it; a referenced binding outside known is +/// watched until that reference goes away. fn forget_binding(s: &mut State, name: &str, vid: Vid) { + let key = binding_key(name, vid); if binding_referenced(s, name, vid) { + if !in_known(s, name, vid) { + s.unbind_watch.insert(key); + } return; } - s.unbound.remove(&format!("{}:{}", name, vid_key(vid))); + s.unbound.remove(&key); + s.unbind_watch.remove(&key); if let Some(item) = s.items.get_mut(name) { item.known.retain(|known| *known != vid); } @@ -281,7 +294,7 @@ fn forget_binding(s: &mut State, name: &str, vid: Vid) { /// Drops a vid binding once it has left the item's known cache and nothing else refers to /// it, so neither the known cap nor removed candidates leave records behind. fn drop_binding(s: &mut State, name: &str, vid: Vid) { - if !s.items.get(name).is_some_and(|i| i.known.contains(&vid)) { + if !in_known(s, name, vid) { forget_binding(s, name, vid); } } @@ -358,6 +371,16 @@ fn prune(s: &mut State, now: i64) { forget_binding(s, &name, vid); } } + // A watched binding back in known is trim_known's again; the rest is retried here. + for entry in std::mem::take(&mut s.unbind_watch) { + let Some((name, vid)) = entry + .rsplit_once(':') + .and_then(|(name, hex)| Some((name.to_owned(), parse_vid(hex)?))) + else { + continue; + }; + drop_binding(s, &name, vid); + } } fn parse_vid(hex: &str) -> Option { let mut vid = [0; 16]; diff --git a/crates/kc-cli/src/sync/state.rs b/crates/kc-cli/src/sync/state.rs index bf945bc..249f8f0 100644 --- a/crates/kc-cli/src/sync/state.rs +++ b/crates/kc-cli/src/sync/state.rs @@ -91,6 +91,11 @@ pub struct State { pub rejected_until: BTreeMap, #[serde(default)] pub unbound: BTreeSet, + /// `name:vid` bindings that left known while something else still referred to them; + /// deleted once nothing does. Bounded per item by its lineage (64), versions and + /// candidates. + #[serde(default)] + pub(crate) unbind_watch: BTreeSet, pub items: BTreeMap, pub peers: BTreeMap, pub generations: Generations, @@ -128,28 +133,41 @@ impl State { } pub fn cleanup(&mut self, ctx: &Ctx<'_, H>) -> Result<()> { super::prune(self, ctx.host.now()); - // A binding scheduled for deletion may have become live again in the same - // transaction (an accepted proposal evicted by its own checkpoint reservation). - let live: BTreeSet = self + // Deletion gate: a binding queued for deletion may have become live again in the + // same transaction (an accepted proposal evicted by its own checkpoint reservation, + // or a rejected vid that an accepted lineage names). Known bindings are left to + // trim_known; the others are watched until nothing refers to them. + let known: BTreeSet = self + .items + .iter() + .flat_map(|(name, i)| i.known.iter().map(|vid| super::record_slot(name, *vid))) + .collect(); + let referenced: BTreeMap = self .items .iter() .flat_map(|(name, i)| { std::iter::once(i.head) - .chain(i.known.iter().copied()) - .map(move |vid| super::record_slot(name, vid)) + .chain(i.lineage.iter().copied()) + .map(move |vid| (name.clone(), vid)) }) - .chain( - self.versions - .values() - .map(|v| super::record_slot(&v.name, v.vid)), - ) + .chain(self.versions.values().map(|v| (v.name.clone(), v.vid))) .chain( self.candidates .values() - .map(|c| super::record_slot(&c.version.name, c.version.vid)), + .map(|c| (c.version.name.clone(), c.version.vid)), ) + .map(|(name, vid)| (super::record_slot(&name, vid), (name, vid))) .collect(); - self.gc.retain(|slot| !live.contains(slot)); + for slot in std::mem::take(&mut self.gc) { + if known.contains(&slot) { + continue; + } + if let Some((name, vid)) = referenced.get(&slot) { + self.unbind_watch.insert(super::binding_key(name, *vid)); + continue; + } + self.gc.insert(slot); + } // Metadata is durable before deletion. A restart repeats only harmless deletes. self.save(&ctx.state)?; for slot in &self.gc { diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs index 9703737..d60b35b 100644 --- a/crates/kc-cli/tests/sync.rs +++ b/crates/kc-cli/tests/sync.rs @@ -2310,7 +2310,8 @@ async fn known_cap_drops_unreferenced_bindings_and_evicted_held_after_it_left_kn .await; b.run(&["inbox"], Run::agent()).await.expect(8); assert!(holds_candidate(&state(&b), held)); - // Preload known past the cap: a lineage vid and the held vid sit first, then fillers. + // Preload known past the cap: a lineage vid and the held vid sit first, then fillers; + // the second filler is an unacknowledged outbound version's vid. let mut s = state(&b); let head = head(&b); let record = b @@ -2333,6 +2334,14 @@ async fn known_cap_drops_unreferenced_bindings_and_evicted_held_after_it_left_kn .as_array_mut() .unwrap() .insert(0, serde_json::to_value(in_lineage).unwrap()); + s["versions"][hex(&fillers[1].0)] = serde_json::json!({ + "name": "KEY", + "vid": fillers[1], + "parents": [head], + "lineage": [head, fillers[1]], + "kind": "text", + "slot": format!("sync/snapshot/{}", hex(&fillers[1].0)), + }); save_state(&b, &s); // A local change adds one more vid, so four fall out of known. b.set("KEY", b"fake-local-change").await; @@ -2345,6 +2354,8 @@ async fn known_cap_drops_unreferenced_bindings_and_evicted_held_after_it_left_kn .unwrap() .is_some() }; + // The version kept its binding through the trim; set's flush then collected it. + assert!(s["versions"].get(hex(&fillers[1].0)).is_none()); assert!(!has(fillers[0]) && !has(fillers[1])); assert!(has(in_lineage) && has(held) && has(fillers[2]) && has(head)); let known: Vec = serde_json::from_value(s["items"]["KEY"]["known"].clone()).unwrap(); @@ -2368,4 +2379,62 @@ async fn known_cap_drops_unreferenced_bindings_and_evicted_held_after_it_left_kn .expect(8); assert!(!holds_candidate(&state(&b), held)); assert!(!has(held)); + // Once the lineage moves on, the lineage vid's binding goes too. + let mut s = state(&b); + s["items"]["KEY"]["lineage"] + .as_array_mut() + .unwrap() + .retain(|v| *v != serde_json::to_value(in_lineage).unwrap()); + save_state(&b, &s); + assert!(has(in_lineage)); + let out = b.run(&["sync"], Run::agent()).await; + assert!([0, 8].contains(&out.code), "{}", out.stderr); + assert!(!has(in_lineage)); + assert!(has(fillers[2]) && has(head)); + assert!(state(&b)["unbind_watch"].as_array().unwrap().is_empty()); +} +#[tokio::test] +async fn rejected_held_vid_named_by_an_accepted_lineage_keeps_its_binding() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let base = head(&b); + // X sorts before Y, so review asks about X first. + let (x, y) = (Vid([1; 16]), Vid([2; 16])); + post( + &a, + &b, + &relay, + change_message("KEY", x, base, b"fake-rejected-x"), + ) + .await; + let mut accepted = change_message("KEY", y, base, b"fake-accepted-y"); + if let SyncMsg::Changes { changes } = &mut accepted { + changes[0].lineage = vec![base, x]; + } + post(&a, &b, &relay, accepted).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let mut s = state(&b); + assert!(holds_candidate(&s, x) && holds_candidate(&s, y)); + // X has already left the known cache. + s["items"]["KEY"]["known"] + .as_array_mut() + .unwrap() + .retain(|v| *v != serde_json::to_value(x).unwrap()); + save_state(&b, &s); + b.run( + &["sync", "review"], + human(vec![Answer::Select(1), Answer::Select(0)]), + ) + .await + .expect(0); + assert_eq!(b.value("KEY").unwrap(), b"fake-accepted-y"); + let lineage: Vec = + serde_json::from_value(state(&b)["items"]["KEY"]["lineage"].clone()).unwrap(); + assert!(lineage.contains(&x)); + assert!( + b.store() + .get_internal(&fp_slot("KEY", x)) + .unwrap() + .is_some() + ); } From a4e9b811f167a8a07a2c1a4ea50f80e4ad9e4df3 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Wed, 14 Oct 2026 10:13:18 +0900 Subject: [PATCH 4/6] =?UTF-8?q?fix(sync):=20=ED=9B=84=EB=B3=B4=EC=9D=98=20?= =?UTF-8?q?parents=C2=B7lineage=20=EC=97=90=20=EB=93=A0=20vid=20=EB=8F=84?= =?UTF-8?q?=20=EB=B0=94=EC=9D=B8=EB=94=A9=20=EC=B0=B8=EC=A1=B0=EB=A1=9C=20?= =?UTF-8?q?=ED=8C=90=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - 같은 review 에서 다른 항목 수락이 먼저 정리를 돌려도, 아직 수락 전인 후보의 조상 vid 레코드를 지우지 않음 Refs DCO-43 Co-Authored-By: Claude Opus 5.5 Claude-Session: https://claude.ai/code/session_01AcJNLuNvFR9uo8NsqLVCj6 --- crates/kc-cli/src/sync/mod.rs | 10 ++++-- crates/kc-cli/src/sync/state.rs | 12 ++++--- crates/kc-cli/tests/sync.rs | 58 +++++++++++++++++++++++++++++++++ 3 files changed, 72 insertions(+), 8 deletions(-) diff --git a/crates/kc-cli/src/sync/mod.rs b/crates/kc-cli/src/sync/mod.rs index 1fd7b5f..3a97a19 100644 --- a/crates/kc-cli/src/sync/mod.rs +++ b/crates/kc-cli/src/sync/mod.rs @@ -257,14 +257,18 @@ fn reserve_keeping( } } /// Whether the head, lineage, a version or a candidate still refers to this vid binding. +/// A candidate's parents and lineage count: accepting it makes them the item's lineage. fn binding_referenced(s: &State, name: &str, vid: Vid) -> bool { s.items .get(name) .is_some_and(|i| i.head == vid || i.lineage.contains(&vid)) || s.versions.values().any(|v| v.name == name && v.vid == vid) - || s.candidates - .values() - .any(|other| other.version.name == name && other.version.vid == vid) + || s.candidates.values().any(|other| { + other.version.name == name + && (other.version.vid == vid + || other.version.parents.contains(&vid) + || other.version.lineage.contains(&vid)) + }) } fn in_known(s: &State, name: &str, vid: Vid) -> bool { s.items.get(name).is_some_and(|i| i.known.contains(&vid)) diff --git a/crates/kc-cli/src/sync/state.rs b/crates/kc-cli/src/sync/state.rs index 249f8f0..b227a1b 100644 --- a/crates/kc-cli/src/sync/state.rs +++ b/crates/kc-cli/src/sync/state.rs @@ -151,11 +151,13 @@ impl State { .map(move |vid| (name.clone(), vid)) }) .chain(self.versions.values().map(|v| (v.name.clone(), v.vid))) - .chain( - self.candidates - .values() - .map(|c| (c.version.name.clone(), c.version.vid)), - ) + // Same set as binding_referenced: a candidate's own vid, parents and lineage. + .chain(self.candidates.values().flat_map(|c| { + std::iter::once(c.version.vid) + .chain(c.version.parents.iter().copied()) + .chain(c.version.lineage.iter().copied()) + .map(|vid| (c.version.name.clone(), vid)) + })) .map(|(name, vid)| (super::record_slot(&name, vid), (name, vid))) .collect(); for slot in std::mem::take(&mut self.gc) { diff --git a/crates/kc-cli/tests/sync.rs b/crates/kc-cli/tests/sync.rs index d60b35b..0266f82 100644 --- a/crates/kc-cli/tests/sync.rs +++ b/crates/kc-cli/tests/sync.rs @@ -2438,3 +2438,61 @@ async fn rejected_held_vid_named_by_an_accepted_lineage_keeps_its_binding() { .is_some() ); } +#[tokio::test] +async fn rejected_held_vid_survives_an_unrelated_accept_before_the_lineage_naming_it() { + let (a, b, relay) = devices().await; + enroll(&a, &b).await; + let base = head(&b); + // Review asks about X, then Z, then Y. + let (x, z, y) = (Vid([1; 16]), Vid([2; 16]), Vid([3; 16])); + post( + &a, + &b, + &relay, + change_message("KEY", x, base, b"fake-rejected-x"), + ) + .await; + post( + &a, + &b, + &relay, + offer_message("OTHER", z, b"fake-other-z", 0), + ) + .await; + let mut accepted = change_message("KEY", y, base, b"fake-accepted-y"); + if let SyncMsg::Changes { changes } = &mut accepted { + changes[0].lineage = vec![base, x]; + } + post(&a, &b, &relay, accepted).await; + b.run(&["inbox"], Run::agent()).await.expect(8); + let mut s = state(&b); + assert!(holds_candidate(&s, x) && holds_candidate(&s, z) && holds_candidate(&s, y)); + // X has already left the known cache. + s["items"]["KEY"]["known"] + .as_array_mut() + .unwrap() + .retain(|v| *v != serde_json::to_value(x).unwrap()); + save_state(&b, &s); + let out = b + .run( + &["sync", "review"], + human(vec![ + Answer::Select(1), + Answer::Select(0), + Answer::Select(0), + ]), + ) + .await; + assert!([0, 8].contains(&out.code), "{}", out.stderr); + assert_eq!(b.value("OTHER").unwrap(), b"fake-other-z"); + assert_eq!(b.value("KEY").unwrap(), b"fake-accepted-y"); + let lineage: Vec = + serde_json::from_value(state(&b)["items"]["KEY"]["lineage"].clone()).unwrap(); + assert!(lineage.contains(&x)); + assert!( + b.store() + .get_internal(&fp_slot("KEY", x)) + .unwrap() + .is_some() + ); +} From 18a079a4fe6542c93243a5d0e3c0f1e52d4d034a Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Wed, 14 Oct 2026 15:01:10 +0900 Subject: [PATCH 5/6] =?UTF-8?q?release:=20v0.3.2=20=EB=A1=9C=20=EB=B2=84?= =?UTF-8?q?=EC=A0=84=20=EC=98=AC=EB=A6=BC?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Refs DCO-43 Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 12 ++++++------ Cargo.toml | 10 +++++----- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index a103644..6fc71d6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1496,7 +1496,7 @@ dependencies = [ [[package]] name = "kc-cli" -version = "0.3.1" +version = "0.3.2" dependencies = [ "base64 0.22.1", "block2", @@ -1535,7 +1535,7 @@ dependencies = [ [[package]] name = "kc-proto" -version = "0.3.1" +version = "0.3.2" dependencies = [ "base64 0.22.1", "chacha20poly1305", @@ -1558,7 +1558,7 @@ dependencies = [ [[package]] name = "kc-relay" -version = "0.3.1" +version = "0.3.2" dependencies = [ "anyhow", "axum", @@ -1586,7 +1586,7 @@ dependencies = [ [[package]] name = "kc-store" -version = "0.3.1" +version = "0.3.2" dependencies = [ "apple-native-keyring-store", "directories", @@ -1610,7 +1610,7 @@ dependencies = [ [[package]] name = "kc-sync" -version = "0.3.1" +version = "0.3.2" dependencies = [ "rand", "serde", @@ -1620,7 +1620,7 @@ dependencies = [ [[package]] name = "kc-wire" -version = "0.3.1" +version = "0.3.2" dependencies = [ "serde", "serde_json", diff --git a/Cargo.toml b/Cargo.toml index 84443cc..e824b8b 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,7 +3,7 @@ resolver = "3" members = ["crates/kc-wire", "crates/kc-proto", "crates/kc-store", "crates/kc-relay", "crates/kc-cli", "crates/kc-sync"] [workspace.package] -version = "0.3.1" +version = "0.3.2" edition = "2024" rust-version = "1.88" license = "MIT" @@ -15,10 +15,10 @@ authors = ["Dcode "] # `dep = { workspace = true, features = [...] }`. A lane that needs a crate that # isn't listed here may add it to its own Cargo.toml directly. [workspace.dependencies] -kc-wire = { path = "crates/kc-wire", version = "0.3.1" } -kc-proto = { path = "crates/kc-proto", version = "0.3.1" } -kc-store = { path = "crates/kc-store", version = "0.3.1" } -kc-sync = { path = "crates/kc-sync", version = "0.3.1" } +kc-wire = { path = "crates/kc-wire", version = "0.3.2" } +kc-proto = { path = "crates/kc-proto", version = "0.3.2" } +kc-store = { path = "crates/kc-store", version = "0.3.2" } +kc-sync = { path = "crates/kc-sync", version = "0.3.2" } anyhow = "1" thiserror = "2" From f1e985f5940a1b3926af6ab510175bcf0073b455 Mon Sep 17 00:00:00 2001 From: seunghan Kim Date: Wed, 14 Oct 2026 15:07:36 +0900 Subject: [PATCH 6/6] =?UTF-8?q?docs(sync):=20kc=20sync=20rm=20=EC=9D=B4=20?= =?UTF-8?q?vid=20=EB=B0=94=EC=9D=B8=EB=94=A9=20=EB=A0=88=EC=BD=94=EB=93=9C?= =?UTF-8?q?=EB=A5=BC=20=EB=82=A8=EA=B8=B0=EB=8A=94=20=EC=9D=B4=EC=9C=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Refs DCO-43 Co-Authored-By: Claude Opus 5.5 --- crates/kc-cli/src/sync/actions.rs | 2 ++ 1 file changed, 2 insertions(+) diff --git a/crates/kc-cli/src/sync/actions.rs b/crates/kc-cli/src/sync/actions.rs index a1002d2..8159054 100644 --- a/crates/kc-cli/src/sync/actions.rs +++ b/crates/kc-cli/src/sync/actions.rs @@ -90,6 +90,8 @@ fn offer(ctx: &mut Ctx<'_, H>, s: &mut State, name: &str, peers: &[Stri } pub(crate) fn remove(ctx: &Ctx<'_, H>, s: &mut State, name: &str) -> Result<()> { let (registration, mut peers) = s.generations.rm(name).map_err(|_| state_error())?; + // The known vids' sync/fp records stay: after `sync add` of the same name, a peer could + // otherwise reuse an old vid with another value under the new generation unquarantined. if let Some(item) = s.items.remove(name) { peers.extend(item.scope.into_iter().map(PeerId)); }