@dinoxx/dinox-cli 1.0.22 → 1.1.1

package/dist/commands/sync.js

@@ -1,18 +1,118 @@
 import { loadConfig } from '../config/store.js';
 import { resolveConfig } from '../config/resolve.js';
 import { hydrateResolvedAuthIdentity } from '../auth/userInfo.js';
+import { withExclusivePowerSync } from '../powersync/exclusiveRuntime.js';
 import { registerStandaloneCommand } from './descriptor/register.js';
 import { FORMAT_OPTIONS, SYNC_TIMEOUT_OPTIONS } from './schema/globalOptions.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../utils/output.js';
 import { parseSyncTimeoutMs } from '../utils/syncTimeout.js';
-import { connectPowerSync, getStatusSnapshot } from '../powersync/runtime.js';
+import { getStatusSnapshot, waitForLastSyncedAfter, } from '../powersync/runtime.js';
 import { runSingleSyncPass } from '../powersync/syncPass.js';
 import { createSyncRequiredError, evaluateSyncGate } from '../powersync/syncGate.js';
+const MAX_SYNC_CLEANUP_RESERVE_MS = 5_000;
+const syncCommandDependencies = {
+    loadConfig,
+    resolveConfig,
+    hydrateResolvedAuthIdentity,
+    withExclusivePowerSync,
+    getRequestedStructuredOutputFormat,
+    getStatusSnapshot,
+    waitForLastSyncedAfter,
+    runSingleSyncPass,
+    printHumanReadableLine,
+    printSuccess,
+    now: Date.now,
+};
+export async function executeSyncCommand(context, overrides = {}) {
+    const dependencies = { ...syncCommandDependencies, ...overrides };
+    const startedAtMs = dependencies.now();
+    const startedAtIso = new Date(startedAtMs).toISOString();
+    const baseConfig = dependencies.resolveConfig(await dependencies.loadConfig());
+    const structuredOutput = dependencies.getRequestedStructuredOutputFormat() !== null;
+    const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? baseConfig.sync.timeoutMs;
+    const deadlineAtMs = startedAtMs + timeoutMs;
+    const cleanupReserveMs = Math.min(MAX_SYNC_CLEANUP_RESERVE_MS, Math.max(1, Math.floor(timeoutMs * 0.2)));
+    const operationDeadlineAtMs = deadlineAtMs - cleanupReserveMs;
+    const remainingTimeoutMs = (reserveMs = 0) => Math.max(1, deadlineAtMs - dependencies.now() - reserveMs);
+    const { config } = await dependencies.hydrateResolvedAuthIdentity(baseConfig, {
+        timeoutMs: remainingTimeoutMs(),
+    });
+    const strict = Boolean(context.options.strict);
+    const result = await dependencies.withExclusivePowerSync({
+        config,
+        offline: false,
+        timeoutMs: remainingTimeoutMs(),
+        deadlineAtMs: operationDeadlineAtMs,
+        waitForInitialSync: false,
+        expectedTokenFingerprint: config.auth.tokenFingerprint ?? null,
+        cleanupFailureMode: 'throw',
+    }, async ({ db, dbPath, stale }) => {
+        const recentSync = strict
+            ? await dependencies.waitForLastSyncedAfter(db, startedAtIso, remainingTimeoutMs(cleanupReserveMs))
+            : true;
+        const syncPass = await dependencies.runSingleSyncPass(db, remainingTimeoutMs(cleanupReserveMs));
+        const status = dependencies.getStatusSnapshot(db);
+        const gate = evaluateSyncGate({
+            offline: false,
+            firstSyncStale: stale,
+            idle: syncPass.downloadIdle,
+            indexComplete: syncPass.tokenIndex.complete,
+            recentSync,
+            status,
+        });
+        const payload = {
+            ok: true,
+            dbPath,
+            stale: !gate.ok,
+            idle: syncPass.idle,
+            downloadIdle: syncPass.downloadIdle,
+            uploadIdle: syncPass.uploadIdle,
+            strict,
+            gate,
+            uploadEnabled: Boolean(config.powersync.uploadBaseUrl),
+            tokenIndex: syncPass.tokenIndex,
+            status,
+        };
+        if (strict && !gate.ok) {
+            throw createSyncRequiredError(gate, status);
+        }
+        return payload;
+    });
+    const payload = {
+        ...result,
+        elapsedMs: Math.max(0, dependencies.now() - startedAtMs),
+    };
+    if (structuredOutput) {
+        dependencies.printSuccess(payload);
+        return;
+    }
+    dependencies.printHumanReadableLine(`db: ${payload.dbPath}`);
+    if (payload.status.lastSyncedAt) {
+        dependencies.printHumanReadableLine(`lastSyncedAt: ${payload.status.lastSyncedAt}`);
+    }
+    if (payload.stale) {
+        dependencies.printHumanReadableLine('warning: sync freshness or local index could not be fully verified');
+    }
+    if (!payload.downloadIdle) {
+        dependencies.printHumanReadableLine('warning: download flow did not settle before timeout');
+    }
+    if (!payload.uploadIdle) {
+        dependencies.printHumanReadableLine('warning: uploads are still active; downloaded data may already be current');
+    }
+    if (!payload.tokenIndex.complete) {
+        dependencies.printHumanReadableLine('warning: local token index did not finish before timeout');
+    }
+    dependencies.printHumanReadableLine(`tokenIndex: complete=${payload.tokenIndex.complete} scanned=${payload.tokenIndex.scanned} reindexed=${payload.tokenIndex.reindexed} skipped=${payload.tokenIndex.skipped} removed=${payload.tokenIndex.removed} ftsRowsUpserted=${payload.tokenIndex.ftsRowsUpserted}`);
+}
 export const syncCommandDescriptor = {
     name: 'sync',
     description: 'Connect and synchronize the local PowerSync database',
     options: [
-        { flags: '--strict', description: 'Fail unless first sync completed, data flow is idle, and no download error exists', type: 'boolean' },
+        {
+            flags: '--strict',
+            description: 'Fail unless connected, a current checkpoint completes, downloads settle, and the local index finishes',
+            type: 'boolean',
+        },
     ],
     schema: {
         path: 'sync',
@@ -22,66 +122,11 @@ export const syncCommandDescriptor = {
         output: {
             type: 'structured',
             summary: 'Sync result with connection status and token index counters',
-            fields: ['dbPath', 'stale', 'idle', 'strict', 'gate', 'uploadEnabled', 'tokenIndex', 'status'],
+            fields: ['dbPath', 'stale', 'idle', 'downloadIdle', 'uploadIdle', 'strict', 'gate', 'uploadEnabled', 'tokenIndex', 'status', 'elapsedMs'],
         },
-        examples: ['dino sync --format json', 'dino sync --strict --sync-timeout 600000 --format json'],
-    },
-    action: async (context) => {
-        const baseConfig = resolveConfig(await loadConfig());
-        const structuredOutput = getRequestedStructuredOutputFormat() !== null;
-        const timeoutMs = parseSyncTimeoutMs(context.globals.syncTimeout) ?? baseConfig.sync.timeoutMs;
-        const { config } = await hydrateResolvedAuthIdentity(baseConfig, { timeoutMs });
-        const { db, dbPath, stale } = await connectPowerSync({
-            config,
-            offline: false,
-            timeoutMs,
-        });
-        try {
-            const syncPass = await runSingleSyncPass(db, timeoutMs);
-            const status = getStatusSnapshot(db);
-            const gate = evaluateSyncGate({
-                offline: false,
-                firstSyncStale: stale,
-                idle: syncPass.idle,
-                status,
-            });
-            const payload = {
-                ok: true,
-                dbPath,
-                stale: !gate.ok,
-                idle: syncPass.idle,
-                strict: Boolean(context.options.strict),
-                gate,
-                uploadEnabled: Boolean(config.powersync.uploadBaseUrl),
-                tokenIndex: syncPass.tokenIndex,
-                status,
-            };
-            if (context.options.strict && !gate.ok) {
-                throw createSyncRequiredError(gate, status);
-            }
-            if (structuredOutput) {
-                printSuccess(payload);
-                return;
-            }
-            printHumanReadableLine(`db: ${payload.dbPath}`);
-            if (!payload.uploadEnabled) {
-                printHumanReadableLine('warning: upload disabled (powersync.uploadBaseUrl is unset)');
-            }
-            if (payload.status.lastSyncedAt) {
-                printHumanReadableLine(`lastSyncedAt: ${payload.status.lastSyncedAt}`);
-            }
-            if (payload.stale) {
-                printHumanReadableLine('warning: sync timed out; local cache may be stale');
-            }
-            if (!payload.idle) {
-                printHumanReadableLine('warning: data flow did not become idle before timeout');
-            }
-            printHumanReadableLine(`tokenIndex: scanned=${payload.tokenIndex.scanned} reindexed=${payload.tokenIndex.reindexed} skipped=${payload.tokenIndex.skipped} removed=${payload.tokenIndex.removed} ftsRowsUpserted=${payload.tokenIndex.ftsRowsUpserted}`);
-        }
-        finally {
-            await db.close().catch(() => undefined);
-        }
+        examples: ['dino sync --sync-timeout 20000 --format json', 'dino sync --strict --sync-timeout 20000 --format json'],
     },
+    action: executeSyncCommand,
 };
 export function registerSyncCommand(program) {
     registerStandaloneCommand(program, syncCommandDescriptor);

package/dist/commands/tags/content.js

@@ -1,4 +1,5 @@
 import { canonicalizeTagPath, isTagPathWithinPrefix, renameTagPathWithPrefix, } from './model.js';
+import { findMarkdownLiteralRanges, isMarkdownOffsetInSortedRanges, } from '../../utils/tiptapMarkdownSyntax.js';
 function dedupeTags(values) {
     const result = [];
     const seen = new Set();
@@ -191,7 +192,15 @@ function rewriteHashtagsInMarkdown(raw, oldPrefix, newPrefix, preserveSuffix) {
     }
     let output = '';
     let changed = false;
+    const protectedRanges = findMarkdownLiteralRanges(raw);
     for (let index = 0; index < raw.length;) {
+        if (isMarkdownOffsetInSortedRanges(index, protectedRanges)) {
+            const range = protectedRanges.find((candidate) => index >= candidate.start && index < candidate.end);
+            const end = range?.end ?? index + 1;
+            output += raw.slice(index, end);
+            index = end;
+            continue;
+        }
         if (raw.charCodeAt(index) !== 0x23) {
             output += raw[index];
             index += 1;

package/dist/commands/tags/index.js

@@ -5,7 +5,7 @@ import { buildTagAddDryRunPreview, buildTagMutationDryRunPreview } from '../writ
 import { printDryRunPreview } from '../../utils/dryRun.js';
 import { DinoxError } from '../../utils/errors.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
-import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
+import { commandStale, printStaleCacheWarning, syncBeforeCommand, waitForMutationUpload, withCommandRuntime, } from '../runtime.js';
 import { addTag, inspectAddTag, listTags } from './repo.js';
 import { getTagStats, getTagTree, inspectTagCleanup, mergeTag, moveTag, renameTag, suggestTagMerges, } from './operations.js';
 const TAG_GLOBAL_OPTIONS = [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS];
@@ -75,7 +75,6 @@ async function runTagAdd(context) {
             userId: identity.userId,
             emoji,
         });
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         const payload = { ok: true, stale: commandStale(runtime), ...result };
         if (structuredOutput) {
@@ -118,7 +117,6 @@ async function runTagRename(context) {
             }));
             return;
         }
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
@@ -144,7 +142,6 @@ async function runTagMove(context) {
             }));
             return;
         }
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
@@ -170,7 +167,6 @@ async function runTagMerge(context) {
             }));
             return;
         }
-        printUploadDisabledWarning(runtime);
         await waitForMutationUpload(runtime);
         printSuccess({ ok: true, stale: commandStale(runtime), ...result });
     });
@@ -193,7 +189,7 @@ async function runTagCleanup(context) {
                 offline: runtime.offline,
                 command: 'dino tag cleanup',
                 action: 'cleanup_tags',
-                risk: 'write',
+                risk: 'read',
                 summary: `Inspect tag cleanup candidates (${result.issues.length} issues).`,
                 inputs: {},
                 targets: result.issues,

package/dist/commands/tags/operations.js

@@ -2,14 +2,15 @@ import { withPowerSyncWriteTransaction } from '../../powersync/runtime.js';
 import { DinoxError } from '../../utils/errors.js';
 import { nowIsoUtc } from '../../utils/time.js';
 import { mergeTagReferencesInNote, renameTagReferencesInNote } from './content.js';
-import { MAX_TAG_PATH_LENGTH, MAX_TAG_SEGMENT_LENGTH, REQUIRED_NOTE_TAG_COLUMNS, REQUIRED_TAG_NODE_COLUMNS, assertMaxLength, canonicalizeTagPath, getLeafName, isActiveTagNode, isActualTagNode, isTagPathWithinPrefix, normalizeTagLookupKey, parseStoredTags, parentPathOf, renameTagPathWithPrefix, trimString, } from './model.js';
+import { MAX_TAG_SEGMENT_LENGTH, REQUIRED_NOTE_TAG_COLUMNS, REQUIRED_TAG_NODE_COLUMNS, canonicalizeTagPath, getLeafName, isActiveTagNode, isActualTagNode, isTagPathWithinPrefix, normalizeTagLookupKey, parseStoredTags, parentPathOf, renameTagPathWithPrefix, trimString, } from './model.js';
 import { activeTagNodes, actualActiveTagNodes, assertCanWriteTag, assertRequiredColumns, assertWritableTagNodes, descendantsOf, ensureNoTagPathConflict, getTableColumns, loadTagNodes, parentIdForPath, requireActiveTagPath, toTagListItem, } from './store.js';
+import { assertTagPathLimits, assertTagTextLimits } from './repo.js';
 function parseSingleSegment(value, label) {
     const normalized = canonicalizeTagPath(value);
     if (!normalized || normalized.includes('/')) {
         throw new DinoxError(`${label} must be a single path segment`);
     }
-    assertMaxLength(label, normalized, MAX_TAG_SEGMENT_LENGTH);
+    assertTagTextLimits(label, normalized, MAX_TAG_SEGMENT_LENGTH);
     return normalized;
 }
 function assertPath(value, label) {
@@ -17,16 +18,20 @@ function assertPath(value, label) {
     if (!normalized) {
         throw new DinoxError(`${label} is required`);
     }
-    assertMaxLength(label, normalized, MAX_TAG_PATH_LENGTH);
+    assertTagPathLimits(normalized, label);
     return normalized;
 }
 function buildSubtreeChanges(nodes, root, newRootPath) {
     const targetPath = assertPath(newRootPath, 'Target tag path');
-    return descendantsOf(nodes, root).map((node) => ({
-        id: node.id,
-        fromPath: node.fullPath,
-        toPath: renameTagPathWithPrefix(node.fullPath, root.fullPath, targetPath),
-    }));
+    return descendantsOf(nodes, root).map((node) => {
+        const toPath = renameTagPathWithPrefix(node.fullPath, root.fullPath, targetPath);
+        assertTagPathLimits(toPath, 'Target tag path');
+        return {
+            id: node.id,
+            fromPath: node.fullPath,
+            toPath,
+        };
+    });
 }
 function toTreeNode(node) {
     return {
@@ -75,13 +80,13 @@ async function loadNoteTagRows(db, userId) {
     FROM c_note
     WHERE TRIM(COALESCE(id, '')) <> ''
       AND (is_del IS NULL OR is_del = 0)
-      AND (TRIM(COALESCE(user_no, '')) = ? OR TRIM(COALESCE(user_no, '')) = '')
+      AND TRIM(COALESCE(user_no, '')) = ?
     `, [userId]);
 }
 async function loadNoteTagStats(db, userId) {
     const normalizedUserId = trimString(userId);
     const userFilter = normalizedUserId
-        ? `AND (TRIM(COALESCE(n.user_no, '')) = ? OR TRIM(COALESCE(n.user_no, '')) = '')`
+        ? `AND TRIM(COALESCE(n.user_no, '')) = ?`
         : '';
     const rows = await db.getAll(`
     SELECT

package/dist/commands/tags/repo.d.ts

@@ -20,6 +20,8 @@ export type InspectAddTagResult = {
     restoredPaths: string[];
     emoji: string;
 };
+export declare function assertTagTextLimits(label: string, value: string, maxLength: number): void;
+export declare function assertTagPathLimits(path: string, label?: string): void;
 export declare function listTags(db: AbstractPowerSyncDatabase, input?: ListTagsInput): Promise<string[]>;
 export declare function addTag(db: AbstractPowerSyncDatabase, input: AddTagInput): Promise<AddTagResult>;
 export declare function inspectAddTag(db: AbstractPowerSyncDatabase, input: AddTagInput): Promise<InspectAddTagResult>;

package/dist/commands/tags/repo.js

@@ -14,6 +14,18 @@ function tagNodeMapByPath(nodes) {
     }
     return map;
 }
+export function assertTagTextLimits(label, value, maxLength) {
+    assertMaxLength(label, value, maxLength);
+    if (Buffer.byteLength(value, 'utf8') > maxLength) {
+        throw new DinoxError(`${label} must be at most ${maxLength} UTF-8 bytes`);
+    }
+}
+export function assertTagPathLimits(path, label = 'Tag path') {
+    assertTagTextLimits(label, path, MAX_TAG_PATH_LENGTH);
+    for (const segment of path.split('/')) {
+        assertTagTextLimits('Tag path segment', segment, MAX_TAG_SEGMENT_LENGTH);
+    }
+}
 function assertAddTagInput(input) {
     const userId = trimString(input.userId);
     const emoji = trimString(input.emoji);
@@ -21,15 +33,15 @@ function assertAddTagInput(input) {
     if (!tag) {
         throw new DinoxError('Tag name is required');
     }
-    assertMaxLength('Tag path', tag, MAX_TAG_PATH_LENGTH);
-    assertMaxLength('Tag name', getLeafName(tag), MAX_TAG_SEGMENT_LENGTH);
-    assertMaxLength('Tag emoji', emoji, MAX_TAG_EMOJI_LENGTH);
+    assertTagPathLimits(tag);
+    assertTagTextLimits('Tag name', getLeafName(tag), MAX_TAG_SEGMENT_LENGTH);
+    assertTagTextLimits('Tag emoji', emoji, MAX_TAG_EMOJI_LENGTH);
     return { tag, userId, emoji };
 }
 export async function listTags(db, input = {}) {
     const userId = trimString(input.userId);
     const userFilter = userId
-        ? `AND (TRIM(COALESCE(user_id, '')) = ? OR TRIM(COALESCE(user_id, '')) = '')`
+        ? `AND TRIM(COALESCE(user_id, '')) = ?`
         : '';
     const rows = await db.getAll(`
     SELECT DISTINCT TRIM(COALESCE(full_path, path_key, '')) AS tag
@@ -112,7 +124,8 @@ export async function addTag(db, input) {
             UPDATE c_tag_node
             SET ${assignments.join(', ')}
             WHERE id = ?
-            `, params);
+              AND TRIM(COALESCE(user_id, '')) = ?
+            `, [...params, userId]);
                     if (existing.isDel === 1) {
                         restoredNodes += 1;
                         existing.isDel = 0;

package/dist/commands/tags/store.js

@@ -20,7 +20,7 @@ export function assertCanWriteTag(columnNames, userId, action) {
 export async function loadTagNodes(db, columnNames, options = {}) {
     const userId = trimString(options.userId);
     const userFilter = userId
-        ? `AND (TRIM(COALESCE(user_id, '')) = ? OR TRIM(COALESCE(user_id, '')) = '')`
+        ? `AND TRIM(COALESCE(user_id, '')) = ?`
         : '';
     const rows = await db.getAll(`
     SELECT

package/dist/commands/todo/contentModel.d.ts

@@ -14,17 +14,18 @@ export type ApplyTaskCheckedStatusResult = {
     nextDoc: JsonRecord;
     taskOrder: string[];
     matchedIndices: number[];
-    changedCount: number;
+    matchedCheckedStates: boolean[];
+    statusChangedCount: number;
 };
 export declare function parseTiptapDocFromDb(rawContentJson: string | null): JsonRecord;
 export declare function createTodoDocFromTasks(taskTexts: string[]): JsonRecord;
 export declare function appendTasksToDoc(doc: JsonRecord, taskTexts: string[]): JsonRecord;
-export declare function deriveImageDetailFromContentJson(doc: JsonRecord): TodoTaskItemNode[];
+export declare function deriveImageDetailFromContentJson(doc: JsonRecord, noteId: string): TodoTaskItemNode[];
 export declare function buildAppendMarkdown(existingMarkdown: string | null, taskTexts: string[]): string;
 export declare function buildCreateMarkdown(taskTexts: string[]): string;
 export declare function buildContentTextPreview(contentMd: string): string;
 export declare function buildSummaryTitle(taskTexts: string[]): string;
 export declare function normalizeTaskTexts(values: string[]): string[];
-export declare function applyTaskCheckedStatus(doc: JsonRecord, taskId: string, checked: boolean): ApplyTaskCheckedStatusResult;
+export declare function applyTaskCheckedStatus(doc: JsonRecord, noteId: string, taskId: string, checked: boolean): ApplyTaskCheckedStatusResult;
 export declare function patchTaskMarkdownByOrder(contentMd: string | null, taskOrder: string[], matchedIndices: number[], checked: boolean): string;
 export {};

package/dist/commands/todo/contentModel.js

@@ -1,6 +1,8 @@
 import { DinoxError } from '../../utils/errors.js';
 import { generateId } from '../../utils/id.js';
 import { stripMarkdown } from '../../utils/text.js';
+import { escapeLiteralMarkdownText, findMarkdownCodeRanges, isMarkdownOffsetInSortedRanges, } from '../../utils/tiptapMarkdownSyntax.js';
+import { buildLegacyTaskId } from './taskIdentity.js';
 const CONTENT_TEXT_PREVIEW_LIMIT = 300;
 const DEFAULT_TITLE_PREFIX = '待办清单';
 export function parseTiptapDocFromDb(rawContentJson) {
@@ -46,10 +48,15 @@ export function appendTasksToDoc(doc, taskTexts) {
     });
     return nextDoc;
 }
-export function deriveImageDetailFromContentJson(doc) {
+export function deriveImageDetailFromContentJson(doc, noteId) {
     const root = assertTiptapDoc(doc);
+    const normalizedNoteId = noteId.trim();
+    if (!normalizedNoteId) {
+        throw new DinoxError('Note id is required to derive todo task details');
+    }
     const rootContent = ensureNodeContentArray(root);
     const result = [];
+    const preorderState = { nextIndex: 0 };
     const nodeStack = [];
     const insideTaskStack = [];
     for (let index = rootContent.length - 1; index >= 0; index -= 1) {
@@ -66,7 +73,7 @@ export function deriveImageDetailFromContentJson(doc) {
         const type = typeof node.type === 'string' ? node.type : '';
         const content = Array.isArray(node.content) ? node.content : [];
         if (type === 'taskItem' && !insideTaskItem) {
-            result.push(normalizeTaskItemNode(node));
+            result.push(normalizeTaskItemNode(node, normalizedNoteId, preorderState));
         }
         const nextInsideTaskItem = insideTaskItem || type === 'taskItem';
         for (let index = content.length - 1; index >= 0; index -= 1) {
@@ -77,9 +84,9 @@ export function deriveImageDetailFromContentJson(doc) {
     return result;
 }
 export function buildAppendMarkdown(existingMarkdown, taskTexts) {
-    const trimmed = (existingMarkdown ?? '').trimEnd();
+    const trimmed = (existingMarkdown ?? '').replace(/(?:\r\n|\n|\r)+$/, '');
     const taskBlock = buildTaskMarkdown(taskTexts);
-    if (!trimmed) {
+    if (!trimmed.trim()) {
         return taskBlock;
     }
     return `${trimmed}\n\n${taskBlock}`;
@@ -111,14 +118,23 @@ export function buildSummaryTitle(taskTexts) {
 }
 export function normalizeTaskTexts(values) {
     const normalized = values
-        .map((value) => value.replace(/\s+/g, ' ').trim())
+        .map((value) => value
+        .replace(/\r\n?/g, '\n')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .join(' '))
         .filter((value) => value.length > 0);
     if (normalized.length === 0) {
         throw new DinoxError('At least one non-empty task is required');
     }
     return normalized;
 }
-export function applyTaskCheckedStatus(doc, taskId, checked) {
+export function applyTaskCheckedStatus(doc, noteId, taskId, checked) {
+    const normalizedNoteId = noteId.trim();
+    if (!normalizedNoteId) {
+        throw new DinoxError('Note id is required');
+    }
     const normalizedTaskId = taskId.trim();
     if (!normalizedTaskId) {
         throw new DinoxError('taskId is required');
@@ -126,7 +142,9 @@ export function applyTaskCheckedStatus(doc, taskId, checked) {
     const nextDoc = cloneJson(assertTiptapDoc(doc));
     const taskOrder = [];
     const matchedIndices = [];
-    let changedCount = 0;
+    const matchedCheckedStates = [];
+    let statusChangedCount = 0;
+    let preorderIndex = 0;
     const visitNode = (value) => {
         if (!value || typeof value !== 'object') {
             return;
@@ -134,22 +152,29 @@ export function applyTaskCheckedStatus(doc, taskId, checked) {
         const node = value;
         const type = typeof node.type === 'string' ? node.type : '';
         if (type === 'taskItem') {
-            const currentTaskId = resolveTaskId(node);
-            if (currentTaskId) {
-                const currentIndex = taskOrder.length;
-                taskOrder.push(currentTaskId);
-                if (currentTaskId === normalizedTaskId) {
-                    matchedIndices.push(currentIndex);
-                    const attrs = ensureNodeAttrs(node);
-                    const previousChecked = normalizeChecked(node.checked) ?? normalizeChecked(attrs.checked) ?? false;
-                    if (previousChecked !== checked) {
-                        changedCount += 1;
-                    }
-                    node.id = currentTaskId;
-                    node.checked = checked;
-                    attrs.id = currentTaskId;
-                    attrs.checked = checked;
+            const explicitTaskId = resolveTaskId(node);
+            const currentTaskId = explicitTaskId || buildLegacyTaskId(normalizedNoteId, preorderIndex, node);
+            preorderIndex += 1;
+            const currentIndex = taskOrder.length;
+            taskOrder.push(currentTaskId);
+            let attrs = null;
+            if (!explicitTaskId) {
+                attrs = ensureNodeAttrs(node);
+                node.id = currentTaskId;
+                attrs.id = currentTaskId;
+            }
+            if (currentTaskId === normalizedTaskId) {
+                matchedIndices.push(currentIndex);
+                attrs ??= ensureNodeAttrs(node);
+                const previousChecked = normalizeChecked(node.checked) ?? normalizeChecked(attrs.checked) ?? false;
+                matchedCheckedStates.push(previousChecked);
+                if (previousChecked !== checked) {
+                    statusChangedCount += 1;
                 }
+                node.id = currentTaskId;
+                node.checked = checked;
+                attrs.id = currentTaskId;
+                attrs.checked = checked;
             }
         }
         const content = Array.isArray(node.content) ? node.content : [];
@@ -162,7 +187,8 @@ export function applyTaskCheckedStatus(doc, taskId, checked) {
         nextDoc,
         taskOrder,
         matchedIndices,
-        changedCount,
+        matchedCheckedStates,
+        statusChangedCount,
     };
 }
 export function patchTaskMarkdownByOrder(contentMd, taskOrder, matchedIndices, checked) {
@@ -174,11 +200,15 @@ export function patchTaskMarkdownByOrder(contentMd, taskOrder, matchedIndices, c
         throw new DinoxError('Cannot update task markdown: note has task entries in content_json but empty content_md.');
     }
     const lines = markdown.split('\n');
+    const codeRanges = findMarkdownCodeRanges(markdown);
     const checklistLineIndexes = [];
+    let lineOffset = 0;
     for (let index = 0; index < lines.length; index += 1) {
-        if (TASK_MARKDOWN_LINE_RE.test(lines[index] ?? '')) {
+        const line = lines[index] ?? '';
+        if (!isMarkdownOffsetInSortedRanges(lineOffset, codeRanges) && TASK_MARKDOWN_LINE_RE.test(line)) {
             checklistLineIndexes.push(index);
         }
+        lineOffset += line.length + (index < lines.length - 1 ? 1 : 0);
     }
     if (checklistLineIndexes.length !== taskOrder.length) {
         throw new DinoxError(`Cannot update task markdown: checklist line count (${checklistLineIndexes.length}) does not match content_json task count (${taskOrder.length}).`);
@@ -220,7 +250,7 @@ function buildTaskItemNodes(taskTexts) {
 }
 function buildTaskMarkdown(taskTexts) {
     const normalizedTasks = normalizeTaskTexts(taskTexts);
-    return normalizedTasks.map((task) => `- [ ] ${task}`).join('\n');
+    return normalizedTasks.map((task) => `- [ ] ${escapeLiteralMarkdownText(task)}`).join('\n');
 }
 function assertTiptapDoc(value) {
     if (!value || typeof value !== 'object') {
@@ -269,11 +299,13 @@ function resolveTaskId(node) {
     const attrsId = normalizeString(attrs?.id);
     return attrsId;
 }
-function normalizeTaskItemNode(node) {
+function normalizeTaskItemNode(node, noteId, preorderState) {
     const attrsSource = isObject(node.attrs) ? node.attrs : {};
     const nodeId = normalizeString(node.id);
     const attrsId = normalizeString(attrsSource.id);
-    const taskId = nodeId || attrsId || generateId();
+    const preorderIndex = preorderState.nextIndex;
+    preorderState.nextIndex += 1;
+    const taskId = nodeId || attrsId || buildLegacyTaskId(noteId, preorderIndex, node);
     const checked = normalizeChecked(node.checked) ?? normalizeChecked(attrsSource.checked) ?? false;
     return {
         type: 'taskItem',
@@ -284,9 +316,27 @@ function normalizeTaskItemNode(node) {
             id: taskId,
             checked,
         },
-        content: Array.isArray(node.content) ? cloneJson(node.content) : [],
+        content: Array.isArray(node.content)
+            ? node.content.map((child) => normalizeTaskDetailContent(child, noteId, preorderState))
+            : [],
     };
 }
+function normalizeTaskDetailContent(value, noteId, preorderState) {
+    if (Array.isArray(value)) {
+        return value.map((item) => normalizeTaskDetailContent(item, noteId, preorderState));
+    }
+    if (!isObject(value)) {
+        return value;
+    }
+    if (value.type === 'taskItem') {
+        return normalizeTaskItemNode(value, noteId, preorderState);
+    }
+    const normalized = {};
+    for (const [key, child] of Object.entries(value)) {
+        normalized[key] = normalizeTaskDetailContent(child, noteId, preorderState);
+    }
+    return normalized;
+}
 function normalizeChecked(value) {
     if (value === true)
         return true;

package/dist/commands/todo/dryRun.d.ts

@@ -19,5 +19,6 @@ export declare function buildTodoUpdateDryRunPreview(args: {
     config: ResolvedDinoxConfig;
     offline: boolean;
     taskId: string;
+    noteId?: string;
     checked: boolean;
 }): Promise<DryRunPreview>;