Fix TUI sync and receipt-backed activation reporting

Cargo.toml

@@ -7,7 +7,7 @@ members = [
 resolver = "2"
 
 [workspace.package]
-version = "0.15.9"
+version = "0.15.10"
 edition = "2021"
 license = "MIT"
 authors = ["TerminallyLazy"]

README.md

@@ -375,7 +375,7 @@ Command ownership is Rust-native:
   normal sensitivity only, bounded cambium/scar/seed classifications, and
   required checkpoint identity, idempotency, and provenance.
 - `evidence` is the Revolve-inspired improvement-loop entry point for evaluated outcomes.
-- `dox sync` and `revolve sync` are read-only source adapters that summarize and point back to authoritative files.
+- `dox sync` and `revolve sync` read source files without changing them and save source-linked summaries to the memory store. Use `--dry-run` to preview without saving.
 - `integrations scan` discovers nearby agent-framework markers and suggests setup paths without changing their config.
 - `export`, `import`, `audit`, `consolidate`, and `maintain` are local maintenance surfaces over the same SQLite store.
 - `policy` manages optional coordinated multi-agent write authorization and its
@@ -669,12 +669,27 @@ Store-watch polling updates persisted counts from SQLite, while the optional
 event stream lights rings in real time without treating stream events as durable
 truth.
 
+The dashboard counts memories saved in the selected project's store. A successful
+harness recall can return zero results from an empty store; its activation receipt
+does not create a memory. Automatic capture adds only durable outcomes selected by
+an agent working in that project.
+
+`/sync` previews DOX summaries from the project's `AGENTS.md` files, including
+local instruction files that may not be tracked in Git. Review the source paths,
+project, destination store and candidates before confirming. Confirmation saves
+that preview and refreshes the dashboard; cancellation leaves memories unchanged.
+Repeated sync updates the same source-linked records rather than duplicating them.
+In Coordinated mode, saving requires the coordinator capability in the terminal
+environment when the TUI starts; preview remains available without it.
+
 Useful keys and commands:
 
 - `s` focuses search, `/` opens the slash command palette, `r` opens exploded
   ring view, `q` quits.
 - `i` toggles sensitive-memory visibility, `u` toggles superseded-memory
   visibility.
+- In the `/sync` preview, `j`/`k` select candidates, Left/Right or Page Up/Down
+  scroll the preview, `y` saves, and `n` or Escape cancels.
 - Slash commands include `/rings`, `/search <query>`, `/remember <summary>`,
   `/forget`, `/redact`, `/promote`, `/scar`, `/seed`, `/supersede <old_id>`,
   `/consolidate`, `/export <file>`, `/sync`, `/integrations`, `/stream`, and

crates/tree-ring-memory-cli/src/actions/adapters.rs

@@ -45,16 +45,25 @@ pub fn sync_dox(
         let store = store.ok_or_else(|| {
             "DOX sync action requires an open writable store when dry_run=false".to_string()
         })?;
-        store
-            .put_many(&report.events)
-            .map_err(|err| err.to_string())?;
+        apply_dox_preview(store, &report)?;
     }
     Ok(DoxSyncActionReport {
         report,
         dry_run: request.dry_run,
     })
 }
 
+/// Persist exactly the candidates returned by a reviewed DOX dry run. Store
+/// validation, atomic batch writes, and coordinated policy still apply.
+pub fn apply_dox_preview(
+    store: &mut SQLiteMemoryStore,
+    report: &DoxSyncReport,
+) -> ActionResult<()> {
+    store
+        .put_many(&report.events)
+        .map_err(|err| err.to_string())
+}
+
 pub fn sync_revolve(
     store: Option<&mut SQLiteMemoryStore>,
     request: RevolveSyncActionRequest,

crates/tree-ring-memory-cli/src/actions/integrations.rs

@@ -220,7 +220,7 @@ pub fn status(request: IntegrationStatusRequest) -> Result<IntegrationStatusActi
             } else if stale_adapter && detected.id != "agent-zero" {
                 "The installed adapter definition is out of date. Review the managed hook files and activation manifest, then reconfigure them with this CLI; preserve the memory database.".to_string()
             } else {
-                next_step_for_state(state, &detected.next_step)
+                next_step_for_state(state, &detected.name, &detected.next_step)
             };
             IntegrationStatusEntry {
                 id: detected.id,
@@ -293,12 +293,39 @@ pub fn activate(
         detection.plan,
         request.accept_managed_block,
     )?;
+    // Publication success describes the bridge, not whether scoped recall has
+    // already run. Reuse status verification without creating a new receipt,
+    // and never let historical proof hide a blocked publication or trust step.
+    let (state, next_step) = if result.state == ActivationState::ConfiguredAwaitingProof {
+        let state = manifest
+            .harnesses
+            .get(&request.harness_id)
+            .and_then(|harness| {
+                let verification = verify_activation_receipts(
+                    &request.memory_root,
+                    &request.harness_id,
+                    &manifest,
+                    harness,
+                );
+                (verification.status == ReceiptVerificationStatus::Valid)
+                    .then_some(verification.receipt)
+                    .flatten()
+            })
+            .map(|receipt| receipt.state)
+            .unwrap_or(result.state);
+        (
+            state,
+            next_step_for_state(state, &detection.name, &result.next_step),
+        )
+    } else {
+        (result.state, result.next_step)
+    };
     Ok(IntegrationLifecycleActionReport {
         harness_id: request.harness_id,
-        state: result.state,
+        state,
         changed_paths: relative_paths(result.changed_paths)?,
         dry_run: false,
-        next_step: result.next_step,
+        next_step,
     })
 }
 
@@ -717,15 +744,19 @@ fn invalid_receipt(
     }
 }
 
-fn next_step_for_state(state: ActivationState, detected_next_step: &str) -> String {
+fn next_step_for_state(
+    state: ActivationState,
+    harness_name: &str,
+    detected_next_step: &str,
+) -> String {
     match state {
         ActivationState::Active => "No action required for the receipt-backed session.".to_string(),
         ActivationState::ActiveIsolated => {
             "Bind the harness to this project's canonical store before claiming shared use."
                 .to_string()
         }
         ActivationState::ConfiguredAwaitingProof => {
-            "Run the adapter preflight at the start of a new harness session.".to_string()
+            format!("Open a new {harness_name} session in this project, then run `tree-ring integrations status --verbose` to verify lifecycle recall.")
         }
         _ => detected_next_step.to_string(),
     }

crates/tree-ring-memory-cli/src/tui/actions.rs

@@ -1,8 +1,8 @@
-use std::path::PathBuf;
+use std::{cell::Cell, path::PathBuf};
 
-use tree_ring_memory_core::ConsolidationRequest;
+use tree_ring_memory_core::{ConsolidationRequest, DoxSyncReport};
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub enum ActionKind {
     Delete,
     Redact,
@@ -22,13 +22,17 @@ pub enum ActionKind {
         include_sensitive: bool,
         include_superseded: bool,
     },
-    Sync,
+    SyncDox {
+        preview: Box<DoxSyncReport>,
+        selected_candidate: usize,
+        preview_scroll: Cell<u16>,
+    },
     RefreshCertification {
         command: String,
     },
 }
 
-#[derive(Debug, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct PendingAction {
     pub kind: ActionKind,
     pub memory_id: Option<String>,
@@ -111,11 +115,31 @@ impl PendingAction {
         }
     }
 
-    pub fn sync_placeholder() -> Self {
+    pub fn sync_dox(preview: DoxSyncReport, project: &str, store_path: &std::path::Path) -> Self {
+        let sensitive_count = preview
+            .events
+            .iter()
+            .filter(|event| event.sensitivity != "normal")
+            .count();
+        let summary = format!(
+            "Import or update {} DOX summaries from {} AGENTS.md files.\nSource: {}\nStore: {}\nProject: {}\nIncludes {} sensitive; skips {} secret sections; {} warnings.\nStable IDs update existing summaries; source files stay authoritative.",
+            preview.memory_count,
+            preview.source_count,
+            preview.root.display(),
+            store_path.display(),
+            project,
+            sensitive_count,
+            preview.skipped_secret_count,
+            preview.warnings.len(),
+        );
         Self {
-            kind: ActionKind::Sync,
+            kind: ActionKind::SyncDox {
+                preview: Box::new(preview),
+                selected_candidate: 0,
+                preview_scroll: Cell::new(0),
+            },
             memory_id: None,
-            summary: "Run integration sync".to_string(),
+            summary,
         }
     }
 
@@ -129,8 +153,9 @@ impl PendingAction {
         }
     }
 
+    #[cfg(test)]
     pub fn confirmation_prompt(&self) -> String {
-        format!("{} - press y to confirm, n/Esc to cancel", self.summary)
+        format!("{}\npress y to confirm, n/Esc to cancel", self.summary)
     }
 }