@dinoxx/dinox-cli 1.0.22 → 1.1.0

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>;

package/dist/commands/todo/dryRun.js

@@ -1,14 +1,11 @@
 import { DinoxError } from '../../utils/errors.js';
-import { applyTaskCheckedStatus, buildSummaryTitle, normalizeTaskTexts, parseTiptapDocFromDb, } from './contentModel.js';
-import { getLatestTodoAppendTarget, getTodoAppendTargetById, loadTodoTaskCandidatesByTaskId, } from './repo.js';
+import { applyTaskCheckedStatus, buildSummaryTitle, normalizeTaskTexts, patchTaskMarkdownByOrder, parseTiptapDocFromDb, } from './contentModel.js';
+import { getLatestTodoAppendTarget, getTodoAppendTargetById, loadTodoTaskCandidatesByTaskId, validateTodoAppendTarget, } from './repo.js';
 function buildExecutionWarnings(config, offline) {
     const warnings = [];
     if (offline) {
         warnings.push('Execution would run in offline mode and only use the local cache.');
     }
-    if (!offline && !config.powersync.uploadBaseUrl) {
-        warnings.push('Execution would be local-only because powersync.uploadBaseUrl is unset.');
-    }
     return warnings;
 }
 export async function buildTodoAppendDryRunPreview(args) {
@@ -24,6 +21,7 @@ export async function buildTodoAppendDryRunPreview(args) {
         }
         throw new DinoxError('No eligible note found for append. Try `dino todo create ...` first.');
     }
+    validateTodoAppendTarget(target);
     return {
         dry_run: true,
         command: 'dino todo append',
@@ -77,23 +75,25 @@ export async function buildTodoUpdateDryRunPreview(args) {
     if (!taskId) {
         throw new DinoxError('taskId is required');
     }
-    const candidates = await loadTodoTaskCandidatesByTaskId(args.db, taskId);
+    const candidates = await loadTodoTaskCandidatesByTaskId(args.db, taskId, { noteId: args.noteId });
     const matches = [];
     for (const candidate of candidates) {
         try {
-            const doc = parseTiptapDocFromDb(candidate.content_json);
-            const applied = applyTaskCheckedStatus(doc, taskId, args.checked);
-            if (applied.matchedIndices.length === 0) {
-                continue;
-            }
             const noteId = (candidate.id ?? '').trim();
             if (!noteId) {
                 continue;
             }
+            const doc = parseTiptapDocFromDb(candidate.content_json);
+            const applied = applyTaskCheckedStatus(doc, noteId, taskId, args.checked);
+            if (applied.matchedIndices.length === 0) {
+                continue;
+            }
             matches.push({
+                applied,
+                contentMd: candidate.content_md,
                 noteId,
                 title: (candidate.title ?? '').trim(),
-                checked: applied.changedCount > 0 ? !args.checked : args.checked,
+                checked: applied.matchedCheckedStates[0] ?? args.checked,
             });
         }
         catch {
@@ -107,6 +107,9 @@ export async function buildTodoUpdateDryRunPreview(args) {
         throw new DinoxError(`Task id is not unique; found in multiple notes: ${matches.map((item) => item.noteId).join(', ')}`);
     }
     const match = matches[0];
+    const nextContentMd = patchTaskMarkdownByOrder(match.contentMd, match.applied.taskOrder, match.applied.matchedIndices, args.checked);
+    const updated = match.applied.statusChangedCount > 0
+        || nextContentMd !== (match.contentMd ?? '');
     return {
         dry_run: true,
         command: 'dino todo update',
@@ -116,6 +119,7 @@ export async function buildTodoUpdateDryRunPreview(args) {
         warnings: buildExecutionWarnings(args.config, args.offline),
         inputs: {
             task_id: taskId,
+            note_id: args.noteId?.trim() || null,
             status_to: args.checked ? 'completed' : 'uncompleted',
         },
         targets: [
@@ -127,7 +131,7 @@ export async function buildTodoUpdateDryRunPreview(args) {
         changes: {
             checked_from: match.checked,
             checked_to: args.checked,
-            updated: match.checked !== args.checked,
+            updated,
         },
     };
 }

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

@@ -1,4 +1,10 @@
 import { Command } from 'commander';
 import type { CommandGroupDescriptor } from '../descriptor/types.js';
+import { type TaskDateRangeFilter } from './repo.js';
+export declare function parseTaskDateRange(input: {
+    from?: unknown;
+    to?: unknown;
+    days?: unknown;
+}, now?: Date): TaskDateRangeFilter | undefined;
 export declare const todoCommandGroup: CommandGroupDescriptor;
 export declare function registerTodoCommands(program: Command): void;