chore(diagnostics): log a proving line for every v1.2.7 change testers confirm from the shared log, and start the release diagnostics ledger

Author: dongdongbh

apps/desktop/src-tauri/src/sync.rs

@@ -1611,7 +1611,10 @@ fn wait_for_dropbox_auth_code(
                     // A callback carrying another attempt's state (a reloaded
                     // tab from an earlier connect, a stale prefetch) is not this
                     // flow's answer; reject it and keep waiting for the real one.
-                    log::warn!("Ignoring Dropbox OAuth callback with a mismatched state");
+                    log::warn!(
+                        target: "sync",
+                        "Ignoring Dropbox OAuth callback with a mismatched state releaseCheck=v1.2.7/dropbox-signin-detached phase=callback-state-mismatch"
+                    );
                     let _ = write_oauth_http_response(
                         &mut stream,
                         "400 Bad Request",
@@ -1630,6 +1633,10 @@ fn wait_for_dropbox_auth_code(
                     return Err("Dropbox authorization failed: missing code".to_string());
                 }
 
+                log::info!(
+                    target: "sync",
+                    "Dropbox sign-in callback accepted with a matching state releaseCheck=v1.2.7/dropbox-signin-detached phase=callback-state-matched"
+                );
                 let _ = write_oauth_http_response(
                     &mut stream,
                     "200 OK",
@@ -2758,6 +2765,10 @@ fn run_dropbox_oauth(
     // sign-in page spun on the redirect, and the Connect button stayed dead.
     open::that_detached(authorize_url.as_str())
         .map_err(|error| format!("Failed to open Dropbox authorization URL: {error}"))?;
+    log::info!(
+        target: "sync",
+        "Dropbox sign-in page opened detached; waiting for the callback releaseCheck=v1.2.7/dropbox-signin-detached phase=opened"
+    );
 
     let code = wait_for_dropbox_auth_code(&listener, &state)?;
     exchange_dropbox_auth_code(

apps/desktop/src/lib/sync-service.ts

@@ -845,7 +845,16 @@ const hasAttachmentSyncWork = async (data: AppData, presenceScope: string | null
 
     // Nothing in the document says there is work to do. The one remaining reason to run the
     // phase is the periodic presence proof.
-    return isAttachmentPresenceReconciliationDue(presenceScope);
+    const presenceDue = isAttachmentPresenceReconciliationDue(presenceScope);
+    void logInfo('Attachment presence re-verification checked', {
+        scope: 'sync',
+        extra: {
+            releaseCheck: 'v1.2.7/daily-attachment-presence',
+            presenceDue: String(presenceDue),
+            hasScope: String(Boolean(presenceScope)),
+        },
+    });
+    return presenceDue;
 };
 
 const getSyncConfigDeps = () => ({

apps/mobile/components/settings/use-sync-settings-transport-actions.test.tsx

@@ -129,6 +129,12 @@ vi.mock('@mindwtr/core', async () => ({
     SYNC_LOCAL_INSECURE_URL_OPTIONS: { allowLocalHostnames: true, allowPrivateIpRanges: true },
 }));
 
+vi.mock('@/lib/app-log', () => ({
+    logInfo: vi.fn(),
+    logWarn: vi.fn(),
+    logError: vi.fn(),
+}));
+
 vi.mock('@/lib/storage-file', () => ({
     pickAndParseSyncFolder: vi.fn(),
 }));

apps/mobile/components/settings/use-sync-settings-transport-actions.ts

@@ -17,6 +17,7 @@ import {
     type AppSettings,
 } from '@mindwtr/core';
 
+import { logInfo } from '@/lib/app-log';
 import { pickAndParseSyncFolder } from '@/lib/storage-file';
 import { getCloudKitAccountStatus } from '@/lib/cloudkit-sync';
 import { authorizeDropbox, getDropboxRedirectUri } from '@/lib/dropbox-oauth';
@@ -830,6 +831,18 @@ export function useSyncSettingsTransportActions({
             };
 
             if (effectiveBackend === 'off') return;
+            // Only an activation passes an explicit backend; a manual "Sync now" tap
+            // calls handleSync() with no options and never reaches this line.
+            if (options?.backend) {
+                void logInfo('Sync backend selected; running the verification sync to activate it', {
+                    scope: 'sync',
+                    extra: {
+                        releaseCheck: 'v1.2.7/sync-settings-activation-mobile',
+                        backend: effectiveBackend,
+                        cloudProvider: effectiveCloudProvider,
+                    },
+                });
+            }
             if (effectiveBackend === 'webdav') {
                 const trimmedWebDavUrl = effectiveWebdav.url.trim();
                 if (!trimmedWebDavUrl) {

apps/mobile/hooks/use-incoming-url.ts

@@ -1,6 +1,8 @@
 import { useEffect, useState } from 'react';
 import * as Linking from 'expo-linking';
 
+import { logInfo } from '@/lib/app-log';
+
 export type IncomingUrl = {
     url: string | null;
     // Increments on every delivery, so the same link opened twice in a row
@@ -13,16 +15,42 @@ export type IncomingUrl = {
 const INITIAL: IncomingUrl = { url: null, key: 0 };
 const DUPLICATE_DELIVERY_WINDOW_MS = 1_000;
 
+// Scheme and host only: a capture link carries the task title in its path/query.
+const logIncomingDelivery = (url: string, delivery: number, deduped: boolean): void => {
+    let scheme = 'none';
+    let host = 'none';
+    try {
+        const parsed = Linking.parse(url);
+        scheme = parsed.scheme ?? 'none';
+        host = parsed.hostname ?? 'none';
+    } catch {
+        // A link the parser rejects is still worth counting.
+    }
+    void logInfo('Incoming link delivered', {
+        scope: 'link',
+        extra: {
+            releaseCheck: 'v1.2.7/incoming-link-redelivery',
+            scheme,
+            host,
+            delivery: String(delivery),
+            deduped: String(deduped),
+        },
+    });
+};
+
 export function useIncomingUrl(): IncomingUrl {
     const [incoming, setIncoming] = useState<IncomingUrl>(INITIAL);
 
     useEffect(() => {
         let cancelled = false;
         let lastDelivery: { url: string | null; at: number } = { url: null, at: 0 };
+        let deliveries = 0;
         Linking.getInitialURL()
             .then((url) => {
                 if (cancelled || !url) return;
                 lastDelivery = { url, at: Date.now() };
+                deliveries += 1;
+                logIncomingDelivery(url, deliveries, false);
                 setIncoming((previous) => (previous.key === 0 ? { url, key: 1 } : previous));
             })
             .catch(() => undefined);
@@ -31,8 +59,13 @@ export function useIncomingUrl(): IncomingUrl {
             // iOS can deliver the launch URL through the event as well as
             // getInitialURL(); a repeat of the same link within a second is
             // that echo, not a second press.
-            if (event.url === lastDelivery.url && now - lastDelivery.at < DUPLICATE_DELIVERY_WINDOW_MS) return;
+            if (event.url === lastDelivery.url && now - lastDelivery.at < DUPLICATE_DELIVERY_WINDOW_MS) {
+                logIncomingDelivery(event.url, deliveries, true);
+                return;
+            }
             lastDelivery = { url: event.url, at: now };
+            deliveries += 1;
+            logIncomingDelivery(event.url, deliveries, false);
             setIncoming((previous) => ({ url: event.url, key: previous.key + 1 }));
         });
         return () => {

apps/mobile/lib/external-calendar.ts

@@ -13,6 +13,7 @@ import {
     type ExternalCalendarSubscription,
 } from '@mindwtr/core';
 import * as FileSystem from './file-system';
+import { logInfo } from './app-log';
 
 export const EXTERNAL_CALENDARS_KEY = 'mindwtr-external-calendars';
 export const SYSTEM_CALENDAR_SETTINGS_KEY = 'mindwtr-system-calendar-settings';
@@ -498,6 +499,31 @@ async function fetchSystemCalendarEvents(rangeStart: Date, rangeEnd: Date, signa
         });
     }
 
+    // #1133/#1134 proof: `spanning` counts the events that cross a window edge — the ones
+    // Android's containment query used to drop before the app ever saw them.
+    const dayMs = 24 * 60 * 60 * 1000;
+    let multiDay = 0;
+    let allDay = 0;
+    let spanning = 0;
+    for (const event of events) {
+        const start = new Date(event.start).getTime();
+        const end = new Date(event.end).getTime();
+        if (end - start > dayMs) multiDay += 1;
+        if (event.allDay) allDay += 1;
+        if (start < rangeStart.getTime() || end > rangeEnd.getTime()) spanning += 1;
+    }
+    void logInfo('Device calendar events loaded for the window', {
+        scope: 'calendar',
+        extra: {
+            releaseCheck: 'v1.2.7/calendar-spanning-events',
+            platform: Platform.OS,
+            total: String(events.length),
+            multiDay: String(multiDay),
+            allDay: String(allDay),
+            spanning: String(spanning),
+        },
+    });
+
     return { calendars, events };
 }
 

apps/mobile/lib/sync-service.ts

@@ -1,7 +1,7 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 import { Platform } from 'react-native';
 import Constants from 'expo-constants';
-import { AppData, SYNC_ENCRYPTION_LOG_EVENTS, buildSyncEncryptionActivationExtra, buildSyncEncryptionErrorExtra, buildSyncEncryptionRemoteReadExtra, buildSyncEncryptionStateExtra, type SyncEncryptionState, type SyncEncryptionStateDecision, acquireSyncRemoteMutationFence, clearIdleSyncCycleSnapshot, createDropboxSyncRemoteMutationFencePort, createSyncOrchestrator, createWebdavSyncRemoteMutationFencePort, probeWebdavSyncCompatibility, runSerializedSyncDocumentOperation, runSharedSyncCycle, useTaskStore, webdavGetSyncDocument, webdavHeadFile, webdavPutSyncDocument, syncEncryptedArtifactName, markRemoteEncryptionDiscovered, markRemotePlaintextDiscovered, SyncEncryptionRemoteConflictError, SyncEncryptionRemotePlaintextError, SyncEncryptionRemoteVersionUnavailableError, SyncEncryptionTerminalError, SyncEncryptionTransitionIncompleteError, SyncFileLockUnavailableError, SyncRemoteWriteConflict, type SyncKeyMaterial, cloudGetJson, cloudHeadJson, cloudPutJson, flushPendingSave, performSyncCycle, withRetry, isRetryableError, isRetryableWebdavReadError, isWebdavInvalidJsonError, normalizeStrongWebdavEtag, normalizeWebdavUrl, normalizeCloudUrl, createSyncBackendIO, buildFastSyncScope, hasPendingSyncSideEffects, injectExternalCalendars as injectExternalCalendarsForSync, persistExternalCalendars as persistExternalCalendarsForSync, getInMemoryAppDataSnapshot, createAbortableFetch, normalizeCloudProvider as normalizeCoreCloudProvider, isDropboxUnauthorizedError, parseFastSyncState, serializeFastSyncState, summarizeTaskLifecycleCounts, decodeUriSafe, buildSyncPayloadTraceExtra, isSyncPayloadTraceEnabled, SYNC_TRACE_EVENT_MESSAGES, SYNC_FILE_NAME, SYNC_REMOTE_MUTATION_REQUEST_HORIZON_MS, CLOUD_PROVIDER_DROPBOX, CLOUD_PROVIDER_SELF_HOSTED, type Attachment, type CloudProvider, type FastSyncState, type SyncBackendContext, type SyncBackendIO, type SyncRunDiagnosticEvent, type SyncRunNotifier, type SyncRunPlatformHooks, type SyncRunResult, type SyncRunStorage, type SyncTransport } from '@mindwtr/core';
+import { AppData, SYNC_ENCRYPTION_LOG_EVENTS, buildSyncEncryptionActivationExtra, buildSyncEncryptionErrorExtra, buildSyncEncryptionRemoteReadExtra, buildSyncEncryptionStateExtra, type SyncEncryptionState, type SyncEncryptionStateDecision, acquireSyncRemoteMutationFence, clearIdleSyncCycleSnapshot, createDropboxSyncRemoteMutationFencePort, createSyncOrchestrator, createWebdavSyncRemoteMutationFencePort, webdavMutationFenceUrl, probeWebdavSyncCompatibility, runSerializedSyncDocumentOperation, runSharedSyncCycle, useTaskStore, webdavGetSyncDocument, webdavHeadFile, webdavPutSyncDocument, syncEncryptedArtifactName, markRemoteEncryptionDiscovered, markRemotePlaintextDiscovered, SyncEncryptionRemoteConflictError, SyncEncryptionRemotePlaintextError, SyncEncryptionRemoteVersionUnavailableError, SyncEncryptionTerminalError, SyncEncryptionTransitionIncompleteError, SyncFileLockUnavailableError, SyncRemoteWriteConflict, type SyncKeyMaterial, cloudGetJson, cloudHeadJson, cloudPutJson, flushPendingSave, performSyncCycle, withRetry, isRetryableError, isRetryableWebdavReadError, isWebdavInvalidJsonError, normalizeStrongWebdavEtag, normalizeWebdavUrl, normalizeCloudUrl, createSyncBackendIO, buildFastSyncScope, hasPendingSyncSideEffects, injectExternalCalendars as injectExternalCalendarsForSync, persistExternalCalendars as persistExternalCalendarsForSync, getInMemoryAppDataSnapshot, createAbortableFetch, normalizeCloudProvider as normalizeCoreCloudProvider, isDropboxUnauthorizedError, parseFastSyncState, serializeFastSyncState, summarizeTaskLifecycleCounts, decodeUriSafe, buildSyncPayloadTraceExtra, isSyncPayloadTraceEnabled, SYNC_TRACE_EVENT_MESSAGES, SYNC_FILE_NAME, SYNC_REMOTE_MUTATION_REQUEST_HORIZON_MS, CLOUD_PROVIDER_DROPBOX, CLOUD_PROVIDER_SELF_HOSTED, type Attachment, type CloudProvider, type FastSyncState, type SyncBackendContext, type SyncBackendIO, type SyncRunDiagnosticEvent, type SyncRunNotifier, type SyncRunPlatformHooks, type SyncRunResult, type SyncRunStorage, type SyncTransport } from '@mindwtr/core';
 import { mobileStorage } from './storage-adapter';
 import { logInfo, logSyncError, logWarn, sanitizeLogMessage } from './app-log';
 import { readSyncFileVersioned, resolveSyncFileUri, writeSyncFile } from './storage-file';
@@ -1528,6 +1528,16 @@ class MobileSyncRun {
             lastSyncHistory: mergedData.settings.lastSyncHistory,
           });
         }
+        void logInfo('Sync status published to the store', {
+          scope: 'sync',
+          extra: {
+            releaseCheck: 'v1.2.7/sync-status-published',
+            backend: this.backend,
+            statusPublished: info.localWriteSkipped ? 'unchanged' : 'wrote-local',
+            lastSyncAt: String(mergedData.settings.lastSyncAt ?? 'none'),
+            lastSyncStatus: String(mergedData.settings.lastSyncStatus ?? 'none'),
+          },
+        });
         logSyncDiagnostic('Sync diagnostic complete', this.syncDiagnosticStartedAt, {
           backend: this.backend,
           step: this.lastStep,
@@ -1573,6 +1583,15 @@ class MobileSyncRun {
         const webdavConfig = this.webdavConfig;
         if (!webdavConfig?.url) throw new Error('WebDAV URL not configured');
         this.ensureWebdavSyncNotRateLimited();
+        // #1132 proof: React Native's URL class ignored pathname writes and resolved the
+        // fence to the sync document itself. The basename below must never be data.json.
+        void logInfo('WebDAV sync fence artifact resolved', {
+          scope: 'sync',
+          extra: {
+            releaseCheck: 'v1.2.7/fence-artifact',
+            artifact: webdavMutationFenceUrl(webdavConfig.url).split('/').pop() ?? 'none',
+          },
+        });
         try {
           return await acquireSyncRemoteMutationFence(
             createWebdavSyncRemoteMutationFencePort(webdavConfig.url, {