fix: track noteHash separately to detect changes beyond 10k chars

space.remanso.note supports up to 30k chars while site.standard.document
only captures the first 10k chars of stripped text. A single contentHash
was insufficient to detect note-only changes in the 10k-30k range,
especially after running sync.

- Add computeNoteHash() hashing raw markdown content up to 30k chars
plus note-specific frontmatter fields (theme, fontSize, fontFamily,
discoverable)
- Store noteHash independently in state, written only after a successful
note create/update — so silent failures are retried on the next run
- Change detection now checks contentHash (document) and noteHash (note)
independently; only the changed record is updated
- Fix sync's matchesPDS to also compare the first 5k chars of note body
content against PDS, preventing incorrect "in sync" verdicts for notes
with content only in the 10k-30k range

packages/cli/src/lib/markdown.ts

···
 	}
 	return stripMarkdownForText(post.content);
 }
+
+const NOTE_CONTENT_MAX = 30000;
+
+export async function computeNoteHash(post: BlogPost): Promise<string> {
+	const key = [
+		post.content.trim().slice(0, NOTE_CONTENT_MAX),
+		post.frontmatter.theme ?? "",
+		String(post.frontmatter.fontSize ?? ""),
+		post.frontmatter.fontFamily ?? "",
+		String(post.frontmatter.discoverable ?? true),
+	].join("\0");
+	return getContentHash(key);
+}

packages/cli/src/lib/types.ts

···
 
 export interface PostState {
 	contentHash: string;
+	noteHash?: string; // hash of note-effective fields (content[0:30000], theme, etc.)
 	atUri?: string;
 	lastPublished?: string;
 	slug?: string; // The generated slug for this post (used by inject command)

packages/remanso-cli/src/commands/publish.ts

···
 	getContentHash,
 	updateFrontmatterWithAtUri,
 	slugifyTitle,
+	computeNoteHash,
 } from "../../../cli/src/lib/markdown";
 import type {
 	BlogPost,
···
 			post: BlogPost;
 			action: "create" | "update";
 			reason: "content changed" | "forced" | "new post" | "missing state";
+			updateDocument: boolean;
+			updateNote: boolean;
 		}> = [];
 		const draftPosts: BlogPost[] = [];
 
···
 				continue;
 			}
 
-			const contentHash = await getContentHash(post.rawContent);
 			const relativeFilePath = path.relative(configDir, post.filePath);
 			const postState = state.posts[relativeFilePath];
 
···
 					post,
 					action: post.frontmatter.atUri ? "update" : "create",
 					reason: "forced",
+					updateDocument: true,
+					updateNote: true,
 				});
 			} else if (!postState) {
 				postsToPublish.push({
 					post,
 					action: post.frontmatter.atUri ? "update" : "create",
 					reason: post.frontmatter.atUri ? "missing state" : "new post",
-				});
-			} else if (postState.contentHash !== contentHash) {
-				postsToPublish.push({
-					post,
-					action: post.frontmatter.atUri ? "update" : "create",
-					reason: "content changed",
+					updateDocument: true,
+					updateNote: true,
 				});
+			} else {
+				const contentHash = await getContentHash(post.rawContent);
+				const noteHash = await computeNoteHash(post);
+
+				const documentChanged = postState.contentHash !== contentHash;
+				// Treat absence of noteHash (legacy state) as changed so we populate it
+				const noteChanged = postState.noteHash
+					? postState.noteHash !== noteHash
+					: true;
+
+				if (documentChanged || noteChanged) {
+					postsToPublish.push({
+						post,
+						action: post.frontmatter.atUri ? "update" : "create",
+						reason: "content changed",
+						updateDocument: documentChanged,
+						updateNote: noteChanged,
+					});
+				}
 			}
 		}
 
···
 			post: BlogPost;
 			action: "create" | "update";
 			atUri: string;
+			updateNote: boolean;
 		}> = [];
 
-		for (const { post, action } of postsToPublish) {
+		for (const { post, action, updateDocument: shouldUpdateDoc, updateNote: shouldUpdateNote } of postsToPublish) {
 			const trimmedContent = post.content.trim();
 			const titleMatch = trimmedContent.match(/^# (.+)$/m);
 			const title = titleMatch ? titleMatch[1] : post.frontmatter.title;
···
 			}
 
 			try {
-				// Handle cover image upload
+				// Handle cover image upload (needed for both document and note)
 				let coverImage: BlobObject | undefined;
 				if (post.frontmatter.ogImage) {
 					const imagePath = await resolveImagePath(
···
 					publishedCount++;
 				} else {
 					atUri = post.frontmatter.atUri!;
-					await updateDocument(
-						agent,
-						post,
-						atUri,
-						publisherConfig as Parameters<typeof updateDocument>[3],
-						coverImage,
-					);
+					if (shouldUpdateDoc) {
+						await updateDocument(
+							agent,
+							post,
+							atUri,
+							publisherConfig as Parameters<typeof updateDocument>[3],
+							coverImage,
+						);
+					}
 					s.stop(`Updated: ${atUri}`);
 
 					contentForHash = post.rawContent;
 					updatedCount++;
 				}
 
-				// Update state
+				// Update state — contentHash updated here (Pass 1 success)
+				// noteHash is updated separately in Pass 2 after note write succeeds
 				const contentHash = await getContentHash(contentForHash);
+				const existingState = state.posts[relativeFilePath];
 				state.posts[relativeFilePath] = {
 					contentHash,
+					// Preserve existing noteHash so Pass 2 can update it separately
+					noteHash: existingState?.noteHash,
 					atUri,
 					lastPublished: new Date().toISOString(),
 					slug: post.slug,
 				};
 
-				noteQueue.push({ post, action, atUri });
+				noteQueue.push({ post, action, atUri, updateNote: shouldUpdateNote });
 			} catch (error) {
 				const errorMessage =
 					error instanceof Error ? error.message : String(error);
···
 		}
 
 		// Pass 2: Create/update Remanso notes
-		for (const { post, action, atUri } of noteQueue) {
+		for (const { post, action, atUri, updateNote: shouldUpdateNote } of noteQueue) {
+			if (!shouldUpdateNote && action !== "create") continue;
+			const relativeFilePath = path.relative(configDir, post.filePath);
 			try {
 				if (action === "create") {
 					await createNote(agent, post, atUri, context);
 				} else {
 					await updateNote(agent, post, atUri, context);
+				}
+				// Store noteHash only after the note record is successfully written
+				const noteHash = await computeNoteHash(post);
+				if (state.posts[relativeFilePath]) {
+					state.posts[relativeFilePath]!.noteHash = noteHash;
 				}
 			} catch (error) {
 				log.warn(

packages/remanso-cli/src/commands/sync.ts

···
 	getContentHash,
 	getTextContent,
 	updateFrontmatterWithAtUri,
+	computeNoteHash,
 } from "../../../cli/src/lib/markdown";
 import { exitOnCancel } from "../../../cli/src/lib/prompts";
 
···
 		return false;
 	}
 
-	// Compare note-specific fields: theme, fontSize, fontFamily
+	// Compare note-specific fields: theme, fontSize, fontFamily, and body content
 	const noteUriMatch = doc.uri.match(/^at:\/\/([^/]+)\/[^/]+\/(.+)$/);
 	if (noteUriMatch) {
 		const repo = noteUriMatch[1]!;
···
 				(localPost.frontmatter.fontFamily || undefined) !==
 					(noteValue.fontFamily as string | undefined) ||
 				localDiscoverable !== noteDiscoverable
+			) {
+				return false;
+			}
+
+			// Compare note body content up to 5000 chars.
+			// Beyond that, image paths are transformed to blob links in PDS,
+			// making direct comparison unreliable without re-uploading images.
+			const pdsNoteContent = (noteValue.content as string | undefined) ?? "";
+			const localNoteContent = localPost.content.trim();
+			const compareLength = Math.min(localNoteContent.length, 5000);
+			if (
+				compareLength > 0 &&
+				pdsNoteContent.slice(0, compareLength) !==
+					localNoteContent.slice(0, compareLength)
 			) {
 				return false;
 			}
···
 				log.message(`    File: ${path.basename(localPost.filePath)}`);
 
 				const contentMatchesPDS = await matchesPDS(localPost, doc, agent);
-				const contentHash = contentMatchesPDS
-					? await getContentHash(localPost.rawContent)
-					: "";
 				const relativeFilePath = path.relative(configDir, localPost.filePath);
 				state.posts[relativeFilePath] = {
-					contentHash,
+					contentHash: contentMatchesPDS
+						? await getContentHash(localPost.rawContent)
+						: "",
+					noteHash: contentMatchesPDS
+						? await computeNoteHash(localPost)
+						: "",
 					atUri: doc.uri,
 					lastPublished: doc.value.publishedAt,
 				};