@dinoxx/dinox-cli 1.0.22 → 1.1.0

package/dist/commands/graph/repo.js

@@ -8,7 +8,7 @@ export async function getBacklinks(db, noteId) {
       n.title
     FROM c_note_link l
     LEFT JOIN c_note n ON l.src_note_id = n.id
-    WHERE l.dst_note_id = ? AND l.is_del = 0 AND (n.is_del = 0 OR n.is_del IS NULL)
+    WHERE l.dst_note_id = ? AND (l.is_del IS NULL OR l.is_del = 0) AND (n.is_del = 0 OR n.is_del IS NULL)
     ORDER BY l.created_at DESC`, [noteId]);
     const backlinks = rows.map((row) => ({
         note_id: row.src_note_id,
@@ -32,7 +32,7 @@ export async function getOutlinks(db, noteId) {
       n.title
     FROM c_note_link l
     LEFT JOIN c_note n ON l.dst_note_id = n.id
-    WHERE l.src_note_id = ? AND l.is_del = 0 AND (n.is_del = 0 OR n.is_del IS NULL)
+    WHERE l.src_note_id = ? AND (l.is_del IS NULL OR l.is_del = 0) AND (n.is_del = 0 OR n.is_del IS NULL)
     ORDER BY l.created_at DESC`, [noteId]);
     const outlinks = rows.map((row) => ({
         note_id: row.dst_note_id,
@@ -46,27 +46,102 @@ export async function getOutlinks(db, noteId) {
         count: outlinks.length,
     };
 }
+// Keep IN-list sizes under SQLite's bound-parameter limit when expanding a frontier.
+const NOTE_LINK_QUERY_CHUNK_SIZE = 500;
+function chunkIds(ids, size) {
+    const chunks = [];
+    for (let i = 0; i < ids.length; i += size) {
+        chunks.push(ids.slice(i, i + size));
+    }
+    return chunks;
+}
+/** Backlinks for many notes at once, grouped by the target (dst) note id. */
+async function getBacklinksForNodes(db, ids) {
+    const grouped = new Map();
+    for (const group of chunkIds(ids, NOTE_LINK_QUERY_CHUNK_SIZE)) {
+        const placeholders = group.map(() => '?').join(', ');
+        const rows = await db.getAll(`SELECT
+        l.id,
+        l.src_note_id,
+        l.dst_note_id,
+        l.relation,
+        l.created_at,
+        n.title
+      FROM c_note_link l
+      LEFT JOIN c_note n ON l.src_note_id = n.id
+      WHERE l.dst_note_id IN (${placeholders}) AND (l.is_del IS NULL OR l.is_del = 0) AND (n.is_del = 0 OR n.is_del IS NULL)
+      ORDER BY l.created_at DESC`, group);
+        for (const row of rows) {
+            const list = grouped.get(row.dst_note_id) ?? [];
+            list.push({
+                note_id: row.src_note_id,
+                title: row.title || '',
+                relation: row.relation,
+                link_created_at: row.created_at,
+            });
+            grouped.set(row.dst_note_id, list);
+        }
+    }
+    return grouped;
+}
+/** Outlinks for many notes at once, grouped by the source (src) note id. */
+async function getOutlinksForNodes(db, ids) {
+    const grouped = new Map();
+    for (const group of chunkIds(ids, NOTE_LINK_QUERY_CHUNK_SIZE)) {
+        const placeholders = group.map(() => '?').join(', ');
+        const rows = await db.getAll(`SELECT
+        l.id,
+        l.src_note_id,
+        l.dst_note_id,
+        l.relation,
+        l.created_at,
+        n.title
+      FROM c_note_link l
+      LEFT JOIN c_note n ON l.dst_note_id = n.id
+      WHERE l.src_note_id IN (${placeholders}) AND (l.is_del IS NULL OR l.is_del = 0) AND (n.is_del = 0 OR n.is_del IS NULL)
+      ORDER BY l.created_at DESC`, group);
+        for (const row of rows) {
+            const list = grouped.get(row.src_note_id) ?? [];
+            list.push({
+                note_id: row.dst_note_id,
+                title: row.title || '',
+                relation: row.relation,
+                link_created_at: row.created_at,
+            });
+            grouped.set(row.src_note_id, list);
+        }
+    }
+    return grouped;
+}
 export async function getRelatedNotes(db, noteId, depth = 2) {
     const visited = new Set([noteId]);
     const related = new Map();
-    async function traverse(currentId, currentDepth) {
-        if (currentDepth > depth)
-            return;
-        const [backlinks, outlinks] = await Promise.all([
-            getBacklinks(db, currentId),
-            getOutlinks(db, currentId),
+    // Breadth-first by degree of separation: each level expands the whole frontier with
+    // two batched queries instead of two per node, so cost is O(depth) round-trips rather
+    // than O(visited nodes). BFS also attaches each note to the link on its shortest path.
+    let frontier = [noteId];
+    for (let level = 1; level <= depth && frontier.length > 0; level += 1) {
+        const [backlinksByDst, outlinksBySrc] = await Promise.all([
+            getBacklinksForNodes(db, frontier),
+            getOutlinksForNodes(db, frontier),
         ]);
-        for (const link of [...backlinks.backlinks, ...outlinks.outlinks]) {
-            if (!visited.has(link.note_id)) {
+        const nextFrontier = [];
+        for (const nodeId of frontier) {
+            const neighbors = [
+                ...(backlinksByDst.get(nodeId) ?? []),
+                ...(outlinksBySrc.get(nodeId) ?? []),
+            ];
+            for (const link of neighbors) {
+                if (visited.has(link.note_id)) {
+                    continue;
+                }
                 visited.add(link.note_id);
                 related.set(link.note_id, link);
-                if (currentDepth < depth) {
-                    await traverse(link.note_id, currentDepth + 1);
-                }
+                nextFrontier.push(link.note_id);
             }
         }
+        frontier = nextFrontier;
     }
-    await traverse(noteId, 1);
     return {
         note_id: noteId,
         related: Array.from(related.values()),
@@ -86,7 +161,7 @@ export async function getGraphStats(db) {
       FROM c_note_link l
       JOIN c_note src ON src.id = l.src_note_id
       JOIN c_note dst ON dst.id = l.dst_note_id
-      WHERE l.is_del = 0
+      WHERE (l.is_del IS NULL OR l.is_del = 0)
         AND (src.is_del IS NULL OR src.is_del = 0)
         AND (dst.is_del IS NULL OR dst.is_del = 0)
       `, []),
@@ -99,7 +174,7 @@ export async function getGraphStats(db) {
           FROM c_note_link l
           JOIN c_note src ON src.id = l.src_note_id
           JOIN c_note dst ON dst.id = l.dst_note_id
-          WHERE l.is_del = 0
+          WHERE (l.is_del IS NULL OR l.is_del = 0)
             AND (src.is_del IS NULL OR src.is_del = 0)
             AND (dst.is_del IS NULL OR dst.is_del = 0)
           UNION
@@ -107,7 +182,7 @@ export async function getGraphStats(db) {
           FROM c_note_link l
           JOIN c_note src ON src.id = l.src_note_id
           JOIN c_note dst ON dst.id = l.dst_note_id
-          WHERE l.is_del = 0
+          WHERE (l.is_del IS NULL OR l.is_del = 0)
             AND (src.is_del IS NULL OR src.is_del = 0)
             AND (dst.is_del IS NULL OR dst.is_del = 0)
         ) all_linked

package/dist/commands/meta/index.js

@@ -1,5 +1,5 @@
 import { registerCommandGroup } from '../descriptor/register.js';
-import { OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
+import { FORMAT_OPTIONS, OFFLINE_OPTIONS, REQUIRE_SYNC_OPTIONS, SYNC_TIMEOUT_OPTIONS } from '../schema/globalOptions.js';
 import { printSuccess } from '../../utils/output.js';
 import { commandStale, syncBeforeCommand, withCommandRuntime } from '../runtime.js';
 import { getMetaSchema, getMetaStats } from './repo.js';
@@ -26,7 +26,7 @@ export const metaCommandGroup = {
                 path: 'meta.stats',
                 risk: 'read',
                 auth: 'required',
-                globalOptions: [...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS],
+                globalOptions: [...FORMAT_OPTIONS, ...OFFLINE_OPTIONS, ...REQUIRE_SYNC_OPTIONS, ...SYNC_TIMEOUT_OPTIONS],
                 output: {
                     type: 'structured',
                     summary: 'Metadata stats payload',
@@ -43,11 +43,11 @@ export const metaCommandGroup = {
                 path: 'meta.schema',
                 risk: 'read',
                 auth: 'none',
-                globalOptions: [],
+                globalOptions: FORMAT_OPTIONS,
                 output: {
                     type: 'structured',
                     summary: 'Structured Dinox data schema payload',
-                    fields: ['tables', 'relations', 'command_schema'],
+                    fields: ['version', 'entities'],
                 },
                 examples: ['dino meta schema --format json'],
             },

package/dist/commands/meta/repo.js

@@ -33,7 +33,7 @@ export function getMetaSchema() {
         version: 1,
         entities: {
             note_search_result: {
-                fields: ['id', 'title', 'summary', 'tags', 'created_at', 'zettel_boxes'],
+                fields: ['id', 'title', 'summary', 'tags', 'created_at', 'boxes', 'is_starred'],
                 meta_fields: [
                     'query',
                     'returned_count',
@@ -55,13 +55,14 @@ export function getMetaSchema() {
                     'created_at',
                     'updated_at',
                     'is_del',
-                    'zettel_boxes',
+                    'is_starred',
+                    'boxes',
                     'links.backlinks',
                     'links.outlinks',
                 ],
             },
             graph_stats: {
-                fields: ['notes_count', 'links_count', 'connected_notes_count', 'isolated_notes_count'],
+                fields: ['notes_count', 'links_count', 'connected_notes_count', 'isolated_notes_count', 'stale'],
             },
             meta_stats: {
                 fields: ['notes_count', 'tags_count', 'boxes_count', 'latest_note_updated_at'],

package/dist/commands/notes/actions.d.ts

@@ -1,5 +1,5 @@
 import type { CommandExecutionContext } from '../descriptor/types.js';
-export declare function runNoteSearch({ command, options, args }: CommandExecutionContext): Promise<void>;
+export declare function runNoteSearch({ command, options, args, globals }: CommandExecutionContext): Promise<void>;
 export declare function runNoteGet({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNotePreview({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNoteDetail({ command, options, args }: CommandExecutionContext): Promise<void>;

package/dist/commands/notes/actions.js

@@ -5,14 +5,16 @@ import { generateId } from '../../utils/id.js';
 import { convertMarkdownToNoteContent } from '../../utils/tiptapMarkdown.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
 import { DinoxError } from '../../utils/errors.js';
-import { commandStale, printStaleCacheWarning, printUploadDisabledWarning, waitForMutationUpload, } from '../runtime.js';
-import { createNote, getNote, getNoteContext, getNoteDetails, getNotePreview, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForSearch, resolveZettelBoxIdsForUpdate, searchNotes, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
+import { commandStale, printStaleCacheWarning, resolveWriteDurabilityForRuntime, waitForMutationUpload, } from '../runtime.js';
+import { createNote, executeNoteSearch, getNote, getNoteContext, getNoteDetails, getNotePreview, assertNotesUpdatable, resolveZettelBoxIdsForCreate, resolveZettelBoxIdsForUpdate, softDeleteNote, updateNote, validateTagsForCreate, validateTagsForUpdate, } from './repo.js';
+import { routeRead } from '../../daemon/route.js';
 import { buildNoteCreateDryRunPreview, buildNoteDeleteDryRunPreview, buildNoteUpdateDryRunPreview, } from './dryRun.js';
 import { applyNoteMetadataMutation, planNoteMetadataMutation, } from './metadataMutation.js';
+import { buildBatchWriteReceiptFields, readNoteRevisionReceipts, readNoteWriteReceipt, } from './writeReceipt.js';
 import { parseNoteSearchFields, projectNoteSearchFields } from './searchOutput.js';
 import { parseCreatedAtRange } from './searchTime.js';
 import { buildNoteSearchResponse, normalizeDaysForMeta } from './searchResponse.js';
-import { parseNoteType, parsePreviewLineCount, parseSearchLimit, parseSearchListInput, parseSearchOffset, parseStarredOption, parseStringInput, parseStringListInput, parseTargetNoteIds, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+import { parseMutationListInput, parseNoteType, parsePreviewLineCount, parseSearchLimit, parseSearchListInput, parseSearchOffset, parseStarredOption, parseStringInput, parseStringListInput, parseTargetNoteIds, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
 function toPublicNoteContext(note) {
     if (!note) {
         return null;
@@ -45,6 +47,7 @@ async function executeNoteUpdateOperation(args) {
     await withNoteDatabase(args.command, async (runtime) => {
         const { db, config, offline } = runtime;
         await syncBeforeNoteCommand(runtime);
+        const durability = resolveWriteDurabilityForRuntime(runtime, args.durability);
         const ids = await parseTargetNoteIds(args.id, args.idsOption, 'update');
         const hasTags = typeof args.tagsOption === 'string';
         const hasBoxes = typeof args.boxOption === 'string';
@@ -52,11 +55,20 @@ async function executeNoteUpdateOperation(args) {
         if (!hasTags && !hasBoxes && !hasStarred) {
             throw new DinoxError('At least one option is required: --tags, --boxes, or --starred');
         }
-        const tags = hasTags
-            ? await validateTagsForUpdate(db, await parseStringListInput(args.tagsOption, '--tags'))
+        const requestedTags = hasTags
+            ? await parseMutationListInput(args.tagsOption, '--tags')
             : undefined;
-        const zettelBoxIds = hasBoxes
-            ? await resolveZettelBoxIdsForUpdate(db, await parseStringListInput(args.boxOption, '--boxes'))
+        const requestedBoxNames = hasBoxes
+            ? await parseMutationListInput(args.boxOption, '--boxes')
+            : undefined;
+        const tagUserId = requestedTags
+            ? (await resolveAuthIdentity(config)).userId
+            : undefined;
+        const tags = requestedTags
+            ? await validateTagsForUpdate(db, requestedTags, tagUserId)
+            : undefined;
+        const zettelBoxIds = requestedBoxNames
+            ? await resolveZettelBoxIdsForUpdate(db, requestedBoxNames)
             : undefined;
         await assertNotesUpdatable(db, ids);
         if (args.dryRun) {
@@ -64,9 +76,10 @@ async function executeNoteUpdateOperation(args) {
                 db,
                 config,
                 offline,
+                userId: tagUserId,
                 ids,
                 tagsInput: tags,
-                zettelBoxNames: hasBoxes ? await parseStringListInput(args.boxOption, '--boxes') : undefined,
+                zettelBoxNames: requestedBoxNames,
                 starred: hasStarred ? args.starred : undefined,
                 commandName: args.commandName ?? 'dino note update',
                 action: args.actionName ?? 'update_note',
@@ -84,20 +97,22 @@ async function executeNoteUpdateOperation(args) {
             }));
         }
         const updatedCount = results.filter((item) => item.updated).length;
-        printUploadDisabledWarning(runtime);
-        await waitForMutationUpload(runtime);
+        const upload = await waitForMutationUpload(runtime, { durability });
+        const stale = commandStale(runtime);
+        const revisions = await readNoteRevisionReceipts(db, results.map((item) => item.id), new Map(results.map((item) => [item.id, item.changed])));
         const payload = {
             ok: true,
             total: results.length,
             updatedCount,
+            ...buildBatchWriteReceiptFields(upload, stale),
             results: results.map((item) => ({
                 id: item.id,
                 updated: item.updated,
                 tags: item.tags,
                 boxes: item.zettelBoxIds,
                 is_starred: item.is_starred,
+                ...revisions.get(item.id),
             })),
-            stale: commandStale(runtime),
         };
         if (structuredOutput) {
             printSuccess(payload);
@@ -144,11 +159,15 @@ async function executeNoteMetadataListOperation(args) {
     await withNoteDatabase(args.command, async (runtime) => {
         const { db, config, offline } = runtime;
         await syncBeforeNoteCommand(runtime);
+        const durability = resolveWriteDurabilityForRuntime(runtime, args.options.durability);
         const ids = await parseTargetNoteIds(args.id, args.idsOption, 'update');
         const selected = selectMetadataOperation(args.options);
-        const requestedValues = await parseStringListInput(selected.rawValues, selected.optionName);
+        const requestedValues = await parseMutationListInput(selected.rawValues, selected.optionName);
+        const tagUserId = args.field === 'tags'
+            ? (await resolveAuthIdentity(config)).userId
+            : undefined;
         const values = args.field === 'tags'
-            ? await validateTagsForUpdate(db, requestedValues)
+            ? await validateTagsForUpdate(db, requestedValues, tagUserId)
             : await resolveZettelBoxIdsForUpdate(db, requestedValues);
         const plan = await planNoteMetadataMutation(db, {
             ids,
@@ -166,9 +185,6 @@ async function executeNoteMetadataListOperation(args) {
                 summary: `Preview ${args.field} ${selected.operation} for ${plan.total} note(s); ${plan.changedCount} note(s) would change.`,
                 warnings: [
                     ...(offline ? ['Execution would run in offline mode and only use the local cache.'] : []),
-                    ...(!offline && !config.powersync.uploadBaseUrl
-                        ? ['Execution would be local-only because powersync.uploadBaseUrl is unset.']
-                        : []),
                 ],
                 inputs: {
                     ids,
@@ -187,20 +203,22 @@ async function executeNoteMetadataListOperation(args) {
             return;
         }
         await applyNoteMetadataMutation(db, plan);
-        printUploadDisabledWarning(runtime);
-        await waitForMutationUpload(runtime);
+        const upload = await waitForMutationUpload(runtime, { durability });
+        const stale = commandStale(runtime);
+        const revisions = await readNoteRevisionReceipts(db, plan.results.map((item) => item.id), new Map(plan.results.map((item) => [item.id, item.changed ? [args.field] : []])));
         const payload = {
             ok: true,
             field: args.field,
             operation: selected.operation,
             total: plan.total,
             updatedCount: plan.changedCount,
+            ...buildBatchWriteReceiptFields(upload, stale),
             results: plan.results.map((item) => ({
                 id: item.id,
                 updated: item.changed,
                 [args.field]: item.after,
+                ...revisions.get(item.id),
             })),
-            stale: commandStale(runtime),
         };
         if (structuredOutput) {
             printSuccess(payload);
@@ -210,60 +228,66 @@ async function executeNoteMetadataListOperation(args) {
         printStaleCacheWarning(runtime);
     });
 }
-export async function runNoteSearch({ command, options, args }) {
+export async function runNoteSearch({ command, options, args, globals }) {
     const searchOptions = options;
-    await withNoteDatabase(command, async (runtime) => {
-        const { db } = runtime;
-        await syncBeforeNoteCommand(runtime);
-        const keyword = args.query?.trim() ?? '';
-        const tagsExpression = typeof searchOptions.tags === 'string' ? searchOptions.tags.trim() : '';
-        const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
-            from: searchOptions.from,
-            to: searchOptions.to,
-            days: searchOptions.days,
-        });
-        const starred = typeof searchOptions.starred === 'string'
-            ? parseStarredOption(searchOptions.starred, '--starred')
-            : undefined;
-        const boxInput = typeof searchOptions.boxes === 'string' ? searchOptions.boxes : '';
-        const parsedBoxInput = boxInput
-            ? await parseSearchListInput(boxInput, '--boxes')
-            : { values: [], isExplicitEmptyArray: false };
-        const zettelBoxIds = await resolveZettelBoxIdsForSearch(db, parsedBoxInput.values);
-        const sqlExpression = typeof searchOptions.sql === 'string' ? searchOptions.sql.trim() : '';
-        const limit = parseSearchLimit(searchOptions.limit);
-        const offset = parseSearchOffset(searchOptions.offset);
-        const fields = parseNoteSearchFields(searchOptions.fields, '--fields');
-        const rows = await searchNotes(db, keyword, {
-            includeDeleted: Boolean(searchOptions.includeDeleted),
-            tagsExpression: tagsExpression || undefined,
-            createdAtFrom,
-            createdAtTo,
-            starred,
-            zettelBoxIds,
-            matchEmptyZettelBoxes: parsedBoxInput.isExplicitEmptyArray,
-            sqlExpression: sqlExpression || undefined,
-        });
-        printSuccess(buildNoteSearchResponse({
-            query: keyword,
-            notes: projectNoteSearchFields(rows.slice(offset, offset + limit), fields),
-            totalCount: rows.length,
-            stale: commandStale(runtime),
-            includeDeleted: Boolean(searchOptions.includeDeleted),
-            limit,
-            offset,
-            fields,
-            tagsExpression: tagsExpression || undefined,
-            createdAtFrom,
-            createdAtTo,
-            days: normalizeDaysForMeta(searchOptions.days),
-            starred,
-            boxNames: parsedBoxInput.values,
-            boxIds: zettelBoxIds,
-            matchEmptyBoxes: parsedBoxInput.isExplicitEmptyArray,
-            sqlExpression: sqlExpression || undefined,
-        }));
+    // Option parsing and output formatting stay here, in one place; only the db-touching
+    // step (box resolution + search) runs through executeNoteSearch — locally or on the daemon.
+    const keyword = args.query?.trim() ?? '';
+    const tagsExpression = typeof searchOptions.tags === 'string' ? searchOptions.tags.trim() : '';
+    const { createdAtFrom, createdAtTo } = parseCreatedAtRange({
+        from: searchOptions.from,
+        to: searchOptions.to,
+        days: searchOptions.days,
     });
+    const starred = typeof searchOptions.starred === 'string'
+        ? parseStarredOption(searchOptions.starred, '--starred')
+        : undefined;
+    const boxInput = typeof searchOptions.boxes === 'string' ? searchOptions.boxes : '';
+    const parsedBoxInput = boxInput
+        ? await parseSearchListInput(boxInput, '--boxes')
+        : { values: [], isExplicitEmptyArray: false };
+    const sqlExpression = typeof searchOptions.sql === 'string' ? searchOptions.sql.trim() : '';
+    const limit = parseSearchLimit(searchOptions.limit);
+    const offset = parseSearchOffset(searchOptions.offset);
+    const fields = parseNoteSearchFields(searchOptions.fields, '--fields');
+    const execParams = {
+        keyword,
+        includeDeleted: Boolean(searchOptions.includeDeleted),
+        tagsExpression: tagsExpression || undefined,
+        createdAtFrom,
+        createdAtTo,
+        starred,
+        boxValues: parsedBoxInput.values,
+        matchEmptyZettelBoxes: parsedBoxInput.isExplicitEmptyArray,
+        sqlExpression: sqlExpression || undefined,
+        limit,
+        offset,
+    };
+    const result = await routeRead(globals, 'note.search', execParams, () => withNoteDatabase(command, async (runtime) => {
+        await syncBeforeNoteCommand(runtime);
+        const local = await executeNoteSearch(runtime.db, execParams);
+        return { ...local, stale: commandStale(runtime) };
+    }));
+    const stale = result.stale ?? false;
+    printSuccess(buildNoteSearchResponse({
+        query: keyword,
+        notes: projectNoteSearchFields(result.rows, fields),
+        totalCount: result.totalCount,
+        stale,
+        includeDeleted: Boolean(searchOptions.includeDeleted),
+        limit,
+        offset,
+        fields,
+        tagsExpression: tagsExpression || undefined,
+        createdAtFrom,
+        createdAtTo,
+        days: normalizeDaysForMeta(searchOptions.days),
+        starred,
+        boxNames: parsedBoxInput.values,
+        boxIds: result.zettelBoxIds,
+        matchEmptyBoxes: parsedBoxInput.isExplicitEmptyArray,
+        sqlExpression: sqlExpression || undefined,
+    }));
 }
 export async function runNoteGet({ command, options, args }) {
     const getOptions = options;
@@ -355,6 +379,7 @@ export async function runNoteCreate({ command, options }) {
     await withNoteDatabase(command, async (runtime) => {
         const { db, config, offline } = runtime;
         await syncBeforeNoteCommand(runtime);
+        const durability = resolveWriteDurabilityForRuntime(runtime, createOptions.durability);
         const identity = await resolveAuthIdentity(config);
         const contentMd = await parseStringInput(String(createOptions.content));
         const canonicalContentMd = await canonicalizeBidlinksInMarkdown(db, contentMd, identity.userId);
@@ -388,13 +413,20 @@ export async function runNoteCreate({ command, options }) {
             contentMd: canonicalContentMd,
             contentJson,
             contentText,
-            tags: await validateTagsForCreate(db, tagsInput),
+            tags: await validateTagsForCreate(db, tagsInput, identity.userId),
             zettelBoxIds: await resolveZettelBoxIdsForCreate(db, boxNames),
             userId: identity.userId,
         });
-        printUploadDisabledWarning(runtime);
-        await waitForMutationUpload(runtime);
-        const payload = { ok: true, id, stale: commandStale(runtime) };
+        const upload = await waitForMutationUpload(runtime, { durability });
+        const payload = {
+            ok: true,
+            id,
+            ...(await readNoteWriteReceipt(db, id, {
+                changed: ['title', 'type', 'content_md', 'content_json', 'content_text', 'tags', 'boxes'],
+                upload,
+                stale: commandStale(runtime),
+            })),
+        };
         if (structuredOutput) {
             printSuccess(payload);
             return;
@@ -413,14 +445,22 @@ export async function runNoteDelete({ command, options, args }) {
     await withNoteDatabase(command, async (runtime) => {
         const { db, config, offline } = runtime;
         await syncBeforeNoteCommand(runtime);
+        const durability = resolveWriteDurabilityForRuntime(runtime, deleteOptions.durability);
         if (Boolean(deleteOptions.dryRun)) {
             printDryRunPreview(await buildNoteDeleteDryRunPreview({ db, config, offline, id }));
             return;
         }
         await softDeleteNote(db, id);
-        printUploadDisabledWarning(runtime);
-        await waitForMutationUpload(runtime);
-        const payload = { ok: true, id, stale: commandStale(runtime) };
+        const upload = await waitForMutationUpload(runtime, { durability });
+        const payload = {
+            ok: true,
+            id,
+            ...(await readNoteWriteReceipt(db, id, {
+                changed: ['is_del'],
+                upload,
+                stale: commandStale(runtime),
+            })),
+        };
         if (structuredOutput) {
             printSuccess(payload);
             return;
@@ -443,6 +483,7 @@ export async function runNoteUpdate({ command, options, args }) {
         tagsOption: updateOptions.tags,
         commandName: 'dino note update',
         actionName: 'update_note',
+        durability: updateOptions.durability,
     });
 }
 export async function runNoteTag({ command, options, args }) {
@@ -479,6 +520,7 @@ export async function runNoteStar({ command, options, args }) {
         staleVerb: 'starred',
         commandName: 'dino note star',
         actionName: 'star_note',
+        durability: starOptions.durability,
     });
 }
 export async function runNoteUnstar({ command, options, args }) {
@@ -493,5 +535,6 @@ export async function runNoteUnstar({ command, options, args }) {
         staleVerb: 'unstarred',
         commandName: 'dino note unstar',
         actionName: 'unstar_note',
+        durability: unstarOptions.durability,
     });
 }

package/dist/commands/notes/bulk.d.ts

@@ -16,6 +16,7 @@ type NoteBulkOptions = {
     boxReplace?: string;
     expectedCount?: string;
     confirm?: boolean;
+    durability?: unknown;
     dryRun?: boolean;
 };
 type NoteBulkMutationSelection = {