@dinoxx/dinox-cli 1.1.0 → 2.0.0

package/dist/commands/notes/bulk.js

@@ -3,12 +3,14 @@ import { printDryRunPreview } from '../../utils/dryRun.js';
 import { getRequestedStructuredOutputFormat, printHumanReadableLine, printSuccess, } from '../../utils/output.js';
 import { DinoxError } from '../../utils/errors.js';
 import { commandStale, printStaleCacheWarning, resolveWriteDurabilityForRuntime, waitForMutationUpload, } from '../runtime.js';
+import { parseExpectedCount } from '../writeConfirmation.js';
 import { resolveZettelBoxIdsForBulk, resolveZettelBoxIdsForSearch, searchNotes, validateTagsForBulk, } from './repo.js';
 import { applyNoteMetadataMutation, planNoteMetadataMutation, } from './metadataMutation.js';
 import { parseCreatedAtRange } from './searchTime.js';
 import { normalizeDaysForMeta, } from './searchResponse.js';
 import { parseMutationListInput, parseSearchListInput, parseStarredOption, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
 import { buildBatchWriteReceiptFields, readNoteRevisionReceipts, } from './writeReceipt.js';
+export { parseExpectedCount };
 const BULK_PREVIEW_LIMIT = 100;
 export function selectBulkMutation(options) {
     const candidates = [
@@ -25,23 +27,6 @@ export function selectBulkMutation(options) {
     }
     return selected[0];
 }
-export function parseExpectedCount(value) {
-    if (value === undefined || value === null || value === '') {
-        return null;
-    }
-    if (typeof value !== 'string') {
-        throw new DinoxError('--expected-count must be a non-negative integer');
-    }
-    const trimmed = value.trim();
-    if (!/^\d+$/.test(trimmed)) {
-        throw new DinoxError('--expected-count must be a non-negative integer');
-    }
-    const parsed = Number(trimmed);
-    if (!Number.isSafeInteger(parsed) || parsed < 0) {
-        throw new DinoxError('--expected-count must be a non-negative integer');
-    }
-    return parsed;
-}
 function hasConcreteTargetFilter(input) {
     const { query, options } = input;
     const hasValue = (value) => typeof value === 'string' && value.trim().length > 0;
@@ -169,7 +154,7 @@ export async function runNoteBulk({ command, options, args }) {
                     [`${selected.field}_to`]: item.after,
                     changed: item.changed,
                 })),
-            });
+            }, runtime);
             return;
         }
         if (!bulkOptions.confirm) {

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

@@ -1,5 +1,6 @@
 import type { AbstractPowerSyncDatabase } from '@powersync/common';
 import { type NoteContentBlockDescriptor, type NoteContentOutlineItem } from './contentEngine.js';
+export type NoteContentReadScope = 'structural-metadata' | 'full-content';
 export type NoteContentPatchOperation = {
     kind: 'appendSection';
     heading: string;
@@ -24,6 +25,7 @@ export type NoteContentReadResult = {
     title: string;
     readToken: string;
     readTokenExpiresAt: string;
+    readTokenScope: NoteContentReadScope;
     base: {
         contentHash: string;
         updatedAt: string | null;
@@ -72,7 +74,9 @@ export declare function planMarkdownPatch(input: {
     contentMd: string;
     operation: NoteContentPatchOperation;
 }): NoteContentPatchPlan;
-export declare function readNoteContentForPatch(db: AbstractPowerSyncDatabase, id: string, databaseScope: string, userId: string): Promise<NoteContentReadResult>;
+export declare function readNoteContentForPatch(db: AbstractPowerSyncDatabase, id: string, databaseScope: string, userId: string, options?: {
+    includeContent?: boolean;
+}): Promise<NoteContentReadResult>;
 export declare function planNoteContentPatch(db: AbstractPowerSyncDatabase, input: {
     id: string;
     userId: string;

package/dist/commands/notes/contentPatch.js

@@ -154,6 +154,7 @@ async function rememberReadToken(input) {
             contentHash: input.contentHash,
             updatedAt: input.updatedAt,
             version: input.version,
+            reviewScope: input.reviewScope,
             createdAt: new Date(nowMs).toISOString(),
             expiresAt,
         };
@@ -296,7 +297,7 @@ export function planMarkdownPatch(input) {
     });
     return plan;
 }
-export async function readNoteContentForPatch(db, id, databaseScope, userId) {
+export async function readNoteContentForPatch(db, id, databaseScope, userId, options = {}) {
     const row = await readNoteContentRow(db, id);
     const tagLookup = await loadTagReferenceLookup(db, userId);
     const document = parseStoredNoteDocument({
@@ -308,18 +309,23 @@ export async function readNoteContentForPatch(db, id, databaseScope, userId) {
     });
     const contentHash = getNoteContentHash(document);
     const version = normalizeVersion(row.version);
+    const readTokenScope = options.includeContent === true
+        ? 'full-content'
+        : 'structural-metadata';
     const token = await rememberReadToken({
         databaseScope,
         noteId: row.id,
         contentHash,
         updatedAt: row.updated_at ?? null,
         version,
+        reviewScope: readTokenScope,
     });
     return {
         noteId: row.id,
         title: row.title?.trim() ?? '',
         readToken: token.token,
         readTokenExpiresAt: token.expiresAt,
+        readTokenScope,
         base: {
             contentHash,
             updatedAt: row.updated_at ?? null,
@@ -353,6 +359,11 @@ export async function applyNoteContentPatch(db, input) {
     if (token.databaseScopeFingerprint !== fingerprintDatabaseScope(input.databaseScope)) {
         throw new DinoxError('read token was issued for a different local account database. Run `dino note content-read <id>` again.');
     }
+    if ('allowProtectedReplace' in input.operation
+        && input.operation.allowProtectedReplace === true
+        && token.reviewScope !== 'full-content') {
+        throw new DinoxError('Protected content replacement requires a full-content read token. Run `dino note content-read <id> --include-content --format json`, review the affected protected blocks, and retry with the new token.');
+    }
     const result = await withPowerSyncWriteTransaction(db, async (tx) => {
         const tagLookup = await loadTagReferenceLookup(tx, input.userId);
         const row = await readNoteContentRow(tx, input.id);

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

@@ -1,3 +1,6 @@
 import type { CommandExecutionContext } from '../descriptor/types.js';
+import type { NoteContentBlockDescriptor } from './contentEngine.js';
+export type PublicNoteContentBlockDescriptor = Pick<NoteContentBlockDescriptor, 'anchorId' | 'hasStableAnchor' | 'nodeIndex' | 'nodeRange' | 'type' | 'editMode' | 'level' | 'textHash' | 'nodeHash' | 'charCount'>;
+export declare function toPublicNoteContentBlocks(blocks: NoteContentBlockDescriptor[]): PublicNoteContentBlockDescriptor[];
 export declare function runNoteContentRead({ command, options, args }: CommandExecutionContext): Promise<void>;
 export declare function runNotePatch({ command, options, args }: CommandExecutionContext): Promise<void>;

package/dist/commands/notes/contentPatchCommand.js

@@ -7,6 +7,20 @@ import { commandStale, printStaleCacheWarning, resolveWriteDurabilityForRuntime,
 import { readNoteWriteReceipt } from './writeReceipt.js';
 import { applyNoteContentPatch, planNoteContentPatch, readNoteContentForPatch, } from './contentPatch.js';
 import { parseStringInput, syncBeforeNoteCommand, withNoteDatabase, } from './runtime.js';
+export function toPublicNoteContentBlocks(blocks) {
+    return blocks.map((block) => ({
+        anchorId: block.anchorId,
+        hasStableAnchor: block.hasStableAnchor,
+        nodeIndex: block.nodeIndex,
+        nodeRange: block.nodeRange,
+        type: block.type,
+        editMode: block.editMode,
+        level: block.level,
+        textHash: block.textHash,
+        nodeHash: block.nodeHash,
+        charCount: block.charCount,
+    }));
+}
 function requireNoteId(id) {
     const normalized = id?.trim() ?? '';
     if (!normalized) {
@@ -60,11 +74,11 @@ export async function runNoteContentRead({ command, options, args }) {
     await withNoteDatabase(command, async (runtime) => {
         await syncBeforeNoteCommand(runtime);
         const identity = await resolveAuthIdentity(runtime.config);
-        const result = await readNoteContentForPatch(runtime.db, id, getPowerSyncDbPath(identity.userId), identity.userId);
-        const { content, ...rest } = result;
+        const result = await readNoteContentForPatch(runtime.db, id, getPowerSyncDbPath(identity.userId), identity.userId, { includeContent: readOptions.includeContent === true });
+        const { content, blocks, ...rest } = result;
         const payload = readOptions.includeContent
-            ? { ...rest, content, stale: commandStale(runtime) }
-            : { ...rest, stale: commandStale(runtime) };
+            ? { ...rest, blocks, content, stale: commandStale(runtime) }
+            : { ...rest, blocks: toPublicNoteContentBlocks(blocks), stale: commandStale(runtime) };
         printSuccess(payload);
     });
 }
@@ -88,6 +102,9 @@ export async function runNotePatch({ command, options, args }) {
                 summary: `Preview ${plan.operation} for note "${plan.title}" (${plan.noteId}); content ${plan.changed ? 'would change' : 'is unchanged'}.`,
                 warnings: [
                     'Run `dino note content-read <id> --format json` before the real edit and pass the returned readToken as --read-token.',
+                    ...('allowProtectedReplace' in operation && operation.allowProtectedReplace === true
+                        ? ['Protected replacement requires `content-read --include-content`; review the affected protected blocks before using its full-content token.']
+                        : []),
                     ...(offline ? ['Execution would run in offline mode and only use the local cache.'] : []),
                 ],
                 inputs: {
@@ -102,12 +119,14 @@ export async function runNotePatch({ command, options, args }) {
                     after_chars: plan.afterContent.length,
                     changed: plan.changed,
                 },
-            });
+            }, runtime);
             return;
         }
-        const readToken = patchOptions.readToken?.trim() ?? '';
+        const readToken = typeof patchOptions.readToken === 'string'
+            ? (await parseStringInput(patchOptions.readToken)).trim()
+            : '';
         if (!readToken) {
-            throw new DinoxError('Real note content edits require --read-token from `dino note content-read <id>`.');
+            throw new DinoxError('Real note content edits require --read-token <token|@file> from `dino note content-read <id>`.');
         }
         const result = await applyNoteContentPatch(db, {
             id,
@@ -124,10 +143,12 @@ export async function runNotePatch({ command, options, args }) {
             upload,
             stale: commandStale(runtime),
         });
-        const { changed: contentChanged, ...publicResult } = result;
+        const { changed: contentChanged, beforeBlocks, afterBlocks, ...publicResult } = result;
         const payload = {
             ok: true,
             ...publicResult,
+            beforeBlocks: toPublicNoteContentBlocks(beforeBlocks),
+            afterBlocks: toPublicNoteContentBlocks(afterBlocks),
             content_changed: contentChanged,
             ...receipt,
         };

package/dist/commands/notes/descriptors.js

@@ -42,7 +42,7 @@ export const noteCommandGroup = {
                 { flags: '--sql <expr>', description: 'SQL-like expression over id/content_md/summary/tags/zettel_boxes/created_at/type/is_starred', type: 'string' },
                 { flags: '--limit <n>', description: 'Maximum returned notes', type: 'number' },
                 { flags: '--offset <n>', description: 'Result offset for pagination', type: 'number', defaultValue: 0 },
-                { flags: '--fields <list>', description: 'Comma-separated fields: id,title,summary,tags,created_at,boxes,is_starred', type: 'string[]' },
+                { flags: '--fields <list>', description: 'Comma-separated fields: id,title,summary,tags,created_at,starred_at,boxes,is_starred', type: 'string[]' },
                 { flags: '--include-deleted', description: 'Include soft-deleted notes', type: 'boolean' },
             ],
             schema: {
@@ -54,7 +54,7 @@ export const noteCommandGroup = {
                     type: 'structured',
                     summary: 'AI-friendly note search payload',
                     entity: 'note_search_result',
-                    fields: ['id', 'title', 'summary', 'tags', 'created_at', 'boxes', 'is_starred'],
+                    fields: ['id', 'title', 'summary', 'tags', 'created_at', 'starred_at', 'boxes', 'is_starred'],
                     metaFields: ['query', 'returned_count', 'total_count', 'stale', 'pagination', 'fields', 'applied_filters'],
                 },
                 examples: [
@@ -66,9 +66,9 @@ export const noteCommandGroup = {
         },
         {
             name: 'get',
-            description: 'Get one note by id, optionally in lightweight context mode',
+            description: 'Get lightweight note context by id without exposing full note content',
             arguments: [{ syntax: '<id>', description: 'Note id' }],
-            options: [{ flags: '--context-only', description: 'Return lightweight note context (title/tags/summary/links)', type: 'boolean' }],
+            options: [{ flags: '--context-only', description: 'Compatibility flag; note get is context-only by default', type: 'boolean' }],
             schema: {
                 path: 'note.get',
                 risk: 'read',
@@ -76,11 +76,11 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Single note or note context payload',
+                    summary: 'Lightweight note context payload; use note detail or content-read --include-content for full content',
                     entity: 'note_context',
-                    fields: ['id', 'title', 'summary', 'tags', 'created_at', 'updated_at', 'is_del', 'boxes', 'links'],
+                    fields: ['stale', 'note.id', 'note.title', 'note.summary', 'note.tags', 'note.created_at', 'note.updated_at', 'note.is_del', 'note.starred_at', 'note.is_starred', 'note.boxes', 'note.links'],
                 },
-                examples: ['dino note get <id> --context-only --format json', 'dino note get <id> --format json'],
+                examples: ['dino note get <id> --format json'],
             },
             action: runNoteGet,
         },
@@ -115,8 +115,8 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'One full note object or an ordered array of note objects',
-                    fields: ['id', 'title', 'content_md', 'content_text', 'content_json', 'tags', 'boxes', 'created_at', 'updated_at', 'is_del'],
+                    summary: 'Ordered full-note collection with freshness metadata',
+                    fields: ['stale', 'count', 'notes.id', 'notes.title', 'notes.content_md', 'notes.content_text', 'notes.content_json', 'notes.properties', 'notes.is_pub', 'notes.starred_at', 'notes.is_starred', 'notes.tags', 'notes.boxes', 'notes.created_at', 'notes.updated_at', 'notes.is_del'],
                 },
                 examples: ['dino note detail <id> --format json', 'dino note detail --ids @/tmp/note-ids.txt --format json'],
             },
@@ -155,7 +155,7 @@ export const noteCommandGroup = {
             description: 'Read note content context and issue a short-lived token required before content patching',
             arguments: [{ syntax: '<id>', description: 'Note id' }],
             options: [
-                { flags: '--include-content', description: 'Include full markdown content in the response', type: 'boolean' },
+                { flags: '--include-content', description: 'Include full markdown plus detailed block text and attributes', type: 'boolean' },
             ],
             schema: {
                 path: 'note.content-read',
@@ -164,10 +164,13 @@ export const noteCommandGroup = {
                 globalOptions: NOTE_GLOBAL_OPTIONS,
                 output: {
                     type: 'structured',
-                    summary: 'Note content read context with readToken, base hash, heading outline, block index, and derived metadata',
-                    fields: ['noteId', 'title', 'readToken', 'readTokenExpiresAt', 'base', 'outline', 'blocks', 'derived', 'content', 'stale'],
+                    summary: 'Privacy-preserving note edit context; full content and detailed blocks require --include-content',
+                    fields: ['noteId', 'title', 'readToken', 'readTokenExpiresAt', 'readTokenScope', 'base', 'outline', 'blocks.type', 'blocks.editMode', 'blocks.nodeRange', 'blocks.textHash', 'blocks.nodeHash', 'blocks.charCount', 'derived', 'content', 'stale'],
                 },
-                examples: ['dino note content-read <id> --include-content --format json'],
+                examples: [
+                    'dino note content-read <id> --format json',
+                    'dino note content-read <id> --include-content --format json',
+                ],
             },
             action: runNoteContentRead,
         },
@@ -295,8 +298,8 @@ export const noteCommandGroup = {
                 { flags: '--replace-block', description: 'Replace one exact markdown block matched by --match', type: 'boolean' },
                 { flags: '--match <string|@file>', description: 'Exact markdown to replace when using --replace-block', type: 'string' },
                 { flags: '--content <string|@file>', description: 'Markdown content to insert', type: 'string' },
-                { flags: '--read-token <token>', description: 'Required for real writes; returned by note content-read', type: 'string' },
-                { flags: '--allow-protected-replace', description: 'Allow replace operations to affect media, table, container, or unknown blocks after reviewing content-read output', type: 'boolean' },
+                { flags: '--read-token <token|@file>', description: 'Single-use patch capability returned by note content-read; prefer @file to avoid exposing it in argv', type: 'string' },
+                { flags: '--allow-protected-replace', description: 'Allow replacement of media, table, container, or unknown blocks only with a reviewed full-content read token', type: 'boolean' },
                 WRITE_DURABILITY_OPTION,
                 { flags: '--dry-run', description: 'Preview the patch without writing', type: 'boolean' },
             ],
@@ -312,7 +315,7 @@ export const noteCommandGroup = {
                 },
                 examples: [
                     'dino note content-read <id> --format json',
-                    'dino note patch <id> --append-section "复盘" --content @/tmp/section.md --read-token <token> --format json',
+                    'dino note patch <id> --append-section "复盘" --content @/tmp/section.md --read-token @/tmp/dinox-read-token --format json',
                 ],
             },
             action: runNotePatch,

package/dist/commands/notes/export.js

@@ -59,6 +59,9 @@ function serializeMarkdownExport(note) {
         tags: note.tags,
         boxes: note.boxes,
         box_ids: note.box_ids,
+        properties: note.properties,
+        is_pub: note.is_pub,
+        starred_at: note.starred_at,
         is_starred: note.is_starred,
         is_del: note.is_del ?? 0,
     }, {

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

@@ -11,6 +11,7 @@ export type NoteRow = {
     created_at: string | null;
     updated_at: string | null;
     is_del: number | null;
+    starred_at: string | null;
     is_starred: number | null;
     version: number | null;
 };
@@ -30,6 +31,7 @@ export type SearchedNote = {
     summary: string;
     tags: string[];
     created_at: string | null;
+    starred_at: string | null;
     is_starred: boolean;
     zettel_boxes: string[];
 };
@@ -42,6 +44,9 @@ export type NoteDetail = {
     source: string | null;
     tags: string[];
     is_del: number | null;
+    is_pub: boolean;
+    properties: Record<string, unknown>;
+    starred_at: string | null;
     is_starred: boolean;
     content_md: string | null;
     content_text: string | null;
@@ -58,6 +63,9 @@ export type NoteExportItem = {
     summary: string | null;
     tags: string[];
     is_del: number | null;
+    is_pub: boolean;
+    properties: Record<string, unknown>;
+    starred_at: string | null;
     is_starred: boolean;
     content_md: string;
     content_text: string | null;
@@ -73,6 +81,7 @@ export type NoteContext = {
     created_at: string | null;
     updated_at: string | null;
     is_del: number | null;
+    starred_at: string | null;
     is_starred: boolean;
     zettel_boxes: string[];
     links: {

package/dist/commands/notes/repo.js

@@ -6,7 +6,7 @@ import { listTags } from '../tags/repo.js';
 import { deriveImageDetailFromContentJson } from '../todo/contentModel.js';
 import { buildNoteSearchSqlFilter } from './searchSql.js';
 const MAX_SEARCH_SUMMARY_CHARS = 200;
-function normalizeStoredStarred(value) {
+function normalizeStoredFlag(value) {
     if (typeof value === 'number') {
         return value === 1;
     }
@@ -15,6 +15,9 @@ function normalizeStoredStarred(value) {
     }
     return false;
 }
+function normalizeStoredStarred(value) {
+    return normalizeStoredFlag(value);
+}
 /**
  * Resolve box names to ids and run the note search. Shared by the local command path and
  * the daemon RPC handler so both produce identical results from one implementation.
@@ -129,7 +132,8 @@ export async function searchNotesPage(db, query, options) {
       n.tags,
       n.zettel_boxes,
       n.created_at,
-      n.is_starred
+      n.starred_at,
+      CASE WHEN n.starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred
     ${baseFromWhere}
     ORDER BY COALESCE(n.updated_at, n.created_at) DESC, n.id DESC
     ${buildPaginationSql(options.limit, options.offset)}
@@ -178,7 +182,8 @@ async function searchNotesWithFts(db, matchQuery, tagFilter, createdAtFilter, st
       n.tags,
       n.zettel_boxes,
       n.created_at,
-      n.is_starred
+      n.starred_at,
+      CASE WHEN n.starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred
     ${baseFromWhere}
     ORDER BY bm25(note_local_fts, 0.0, 8.0, 4.0, 1.0) ASC, COALESCE(n.updated_at, n.created_at) DESC, n.id DESC
     ${buildPaginationSql(limit, offset)}
@@ -219,6 +224,7 @@ async function enrichSearchRows(db, rows) {
             summary,
             tags: parseStoredTags(row.tags),
             created_at: row.created_at,
+            starred_at: row.starred_at ?? null,
             is_starred: normalizeStoredStarred(row.is_starred),
             zettel_boxes: zettelBoxes,
         };
@@ -342,8 +348,8 @@ function buildStarredFilter(starred, noteAlias) {
         return null;
     }
     return {
-        sql: `(${noteAlias}.is_starred = ?)`,
-        params: [starred ? '1' : '0'],
+        sql: starred ? `(${noteAlias}.starred_at IS NOT NULL)` : `(${noteAlias}.starred_at IS NULL)`,
+        params: [],
     };
 }
 function buildZettelBoxFilter(zettelBoxIds, matchEmptyZettelBoxes, noteAlias) {
@@ -588,7 +594,8 @@ export async function getNote(db, id) {
       created_at,
       updated_at,
       is_del,
-      is_starred,
+      starred_at,
+      CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
       version
     FROM c_note
     WHERE id = ?
@@ -638,7 +645,8 @@ export async function getNoteContext(db, id) {
       n.created_at,
       n.updated_at,
       n.is_del,
-      n.is_starred,
+      n.starred_at,
+      CASE WHEN n.starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
       n.zettel_boxes AS zettel_boxes_raw
     FROM c_note n
     WHERE n.id = ?
@@ -660,6 +668,7 @@ export async function getNoteContext(db, id) {
         created_at: row.created_at,
         updated_at: row.updated_at,
         is_del: row.is_del,
+        starred_at: row.starred_at ?? null,
         is_starred: normalizeStoredStarred(row.is_starred),
         zettel_boxes: boxIds
             .map((boxId) => boxNameMap.get(boxId))
@@ -709,6 +718,9 @@ function mapNoteDetailRow(note, boxNameMap) {
         source: note.source,
         tags: parseStoredTags(note.tags),
         is_del: note.is_del,
+        is_pub: normalizeStoredFlag(note.is_pub),
+        properties: parseStoredNoteProperties(note.properties),
+        starred_at: note.starred_at ?? null,
         is_starred: normalizeStoredStarred(note.is_starred),
         content_md: note.content_md,
         content_text: note.content_text,
@@ -728,6 +740,30 @@ function parseStoredJsonValue(raw) {
         return raw;
     }
 }
+function parseStoredNoteProperties(raw) {
+    const value = raw?.trim() ?? '';
+    if (!value) {
+        return {};
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (cause) {
+        throw new DinoxError('c_note.properties must be valid JSON', {
+            code: 'NOTE_INVALID_PROPERTIES',
+            details: { cause: cause instanceof Error ? cause.message : String(cause) },
+            recoverable: false,
+        });
+    }
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new DinoxError('c_note.properties must be a JSON object', {
+            code: 'NOTE_INVALID_PROPERTIES',
+            recoverable: false,
+        });
+    }
+    return Object.fromEntries(Object.entries(parsed));
+}
 function mapNoteExportRow(note, boxNameMap) {
     const boxIds = parseZettelBoxIds(note.zettel_boxes_raw);
     const boxes = boxIds
@@ -743,6 +779,9 @@ function mapNoteExportRow(note, boxNameMap) {
         summary: note.summary,
         tags: parseStoredTags(note.tags),
         is_del: note.is_del,
+        is_pub: normalizeStoredFlag(note.is_pub),
+        properties: parseStoredNoteProperties(note.properties),
+        starred_at: note.starred_at ?? null,
         is_starred: normalizeStoredStarred(note.is_starred),
         content_md: note.content_md ?? '',
         content_text: note.content_text,
@@ -773,7 +812,10 @@ export async function getNoteDetails(db, ids) {
         source,
         tags,
         is_del,
-        is_starred,
+        is_pub,
+        properties,
+        starred_at,
+        CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
         content_md,
         content_text,
         content_json,
@@ -828,7 +870,10 @@ export async function getNoteExportItems(db, ids) {
         tags,
         summary,
         is_del,
-        is_starred,
+        is_pub,
+        properties,
+        starred_at,
+        CASE WHEN starred_at IS NOT NULL THEN 1 ELSE 0 END AS is_starred,
         content_md,
         content_text,
         content_json,
@@ -930,11 +975,13 @@ export async function createNote(db, input) {
         ['resource_id', null],
         ['note_ids', '[]'],
         ['extra_data', '{}'],
+        ['properties', null],
+        ['is_pub', 0],
         ['format_type', ''],
         ['comments', '[]'],
-        ['is_starred', 0],
         ['is_top', 0],
         ['pinned_at', '1997-01-01T00:00:00.000Z'],
+        ['starred_at', null],
         ['chat_context', '{}'],
         ['bid_links', '[]'],
     ];
@@ -1082,7 +1129,7 @@ export async function updateNote(db, input) {
         throw new DinoxError('At least one field is required: tags, boxes, or starred');
     }
     const existing = await db.getOptional(`
-    SELECT id, tags, zettel_boxes, is_del, is_starred
+    SELECT id, tags, zettel_boxes, is_del, starred_at
     FROM c_note
     WHERE id = ?
     `, [id]);
@@ -1094,7 +1141,7 @@ export async function updateNote(db, input) {
     }
     const currentTags = parseStoredTags(existing.tags);
     const currentZettelBoxIds = parseZettelBoxIds(existing.zettel_boxes);
-    const currentStarred = normalizeStoredStarred(existing.is_starred);
+    const currentStarred = existing.starred_at !== null;
     const nextTags = shouldUpdateTags ? normalizeDistinctStrings(input.tags) : currentTags;
     const nextZettelBoxIds = shouldUpdateBoxes ? normalizeDistinctStrings(input.zettelBoxIds) : currentZettelBoxIds;
     const nextStarred = shouldUpdateStarred ? input.starred : currentStarred;
@@ -1122,11 +1169,14 @@ export async function updateNote(db, input) {
         params.push(JSON.stringify(nextZettelBoxIds));
     }
     if (starredChanged) {
-        setParts.push('is_starred = ?');
-        params.push(nextStarred ? 1 : 0);
+        setParts.push('starred_at = ?');
+    }
+    const updatedAt = nowIsoUtc();
+    if (starredChanged) {
+        params.push(nextStarred ? updatedAt : null);
     }
     setParts.push('updated_at = ?');
-    params.push(nowIsoUtc());
+    params.push(updatedAt);
     setParts.push('version = COALESCE(version, 0) + 1');
     params.push(id);
     await db.execute(`

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

@@ -1,5 +1,5 @@
 import type { SearchedNote } from './repo.js';
-export declare const NOTE_SEARCH_FIELDS: readonly ["id", "title", "summary", "tags", "created_at", "boxes", "is_starred"];
+export declare const NOTE_SEARCH_FIELDS: readonly ["id", "title", "summary", "tags", "created_at", "starred_at", "boxes", "is_starred"];
 export type NoteSearchField = (typeof NOTE_SEARCH_FIELDS)[number];
 export type NoteSearchResultItem = {
     id?: string;
@@ -7,6 +7,7 @@ export type NoteSearchResultItem = {
     summary?: string;
     tags?: string[];
     created_at?: string | null;
+    starred_at?: string | null;
     is_starred?: boolean;
     boxes?: string[];
 };

package/dist/commands/notes/searchOutput.js

@@ -1,5 +1,5 @@
 import { DinoxError } from '../../utils/errors.js';
-export const NOTE_SEARCH_FIELDS = ['id', 'title', 'summary', 'tags', 'created_at', 'boxes', 'is_starred'];
+export const NOTE_SEARCH_FIELDS = ['id', 'title', 'summary', 'tags', 'created_at', 'starred_at', 'boxes', 'is_starred'];
 const NOTE_SEARCH_FIELD_SET = new Set(NOTE_SEARCH_FIELDS);
 export function parseNoteSearchFields(value, optionName) {
     if (value === undefined || value === null || value === '') {
@@ -35,6 +35,7 @@ export function projectNoteSearchFields(notes, fields) {
             summary: note.summary,
             tags: note.tags,
             created_at: note.created_at,
+            starred_at: note.starred_at,
             is_starred: note.is_starred,
             boxes: note.zettel_boxes,
         }));

package/dist/commands/notes/searchSql.js

@@ -32,8 +32,14 @@ const SCALAR_FIELD_COLUMNS = {
     summary: 'summary',
     created_at: 'created_at',
     type: 'type',
-    is_starred: 'is_starred',
+    is_starred: 'starred_at',
 };
+function scalarFieldSql(field, noteAlias) {
+    if (field === 'is_starred') {
+        return `(CASE WHEN ${noteAlias}.starred_at IS NOT NULL THEN 1 ELSE 0 END)`;
+    }
+    return `${noteAlias}.${SCALAR_FIELD_COLUMNS[field]}`;
+}
 export async function buildNoteSearchSqlFilter(options) {
     const expression = options.expression?.trim() ?? '';
     if (!expression) {
@@ -527,7 +533,7 @@ function compileComparison(node, noteAlias, params, zettelBoxIdByName) {
     `;
         return node.operator === '!=' ? `NOT (${existsSql})` : existsSql;
     }
-    const column = `${noteAlias}.${SCALAR_FIELD_COLUMNS[node.field]}`;
+    const column = scalarFieldSql(node.field, noteAlias);
     params.push(node.value);
     if (node.operator === 'LIKE' || node.operator === 'NOT LIKE') {
         return `(${column} IS NOT NULL AND ${column} ${node.operator} ?)`;
@@ -586,7 +592,7 @@ function compileInCondition(node, noteAlias, params, zettelBoxIdByName) {
     if (values.length === 0) {
         throw new Error('IN list cannot be empty');
     }
-    const column = `${noteAlias}.${SCALAR_FIELD_COLUMNS[node.field]}`;
+    const column = scalarFieldSql(node.field, noteAlias);
     const placeholders = values.map(() => '?').join(', ');
     params.push(...values);
     if (node.not) {

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

@@ -1,4 +1,5 @@
 import { Command } from 'commander';
 import type { CommandGroupDescriptor } from '../descriptor/types.js';
+export declare function parsePromptTextInput(value: unknown): Promise<string>;
 export declare const promptCommandGroup: CommandGroupDescriptor;
 export declare function registerPromptCommands(program: Command): void;