things-api 0.13.0 → 0.15.0

package/dist/client.d.ts

@@ -5,18 +5,20 @@
 import type { AuditWriter } from "./audit/log.ts";
 import { type ThingsApiConfig } from "./config.ts";
 import { type ClockMeta } from "./model/clock.ts";
-import { type Truncation } from "./contracts.ts";
+import { type GroupBlock, type Truncation } from "./contracts.ts";
 import { type FingerprintStatus, type SchemaStatus } from "./db/fingerprint.ts";
 import type { AnyTask, Area, Project, Tag } from "./model/entities.ts";
 import type { RefPromoter } from "./read/shape.ts";
 import { type AreaView } from "./read/area-view.ts";
+import { type LogState } from "./read/log-boundary.ts";
 import { type ProjectView } from "./read/project-view.ts";
 import { type Snapshot } from "./read/snapshot.ts";
 import { type ShowTarget } from "./read/show-target.ts";
-import { type ChangedItem, type InboxFilter, type LiteSearchResult, type ListItem, type LogbookFilter, type SearchOptions, type SearchResultItem, type SidebarSection, type SomedayFilter, type TodayFilter, type TodayView, type UpcomingFilter, type ViewFilter } from "./read/views.ts";
+import { type ChangedItem, type DeadlinesFilter, type InboxFilter, type LiteSearchResult, type ListItem, type LogbookFilter, type SearchOptions, type SearchResultItem, type SidebarSection, type SomedayFilter, type TodayFilter, type TodayView, type UpcomingFilter, type ViewFilter } from "./read/views.ts";
+import { type TodayBucketTotals, type AreaBucketTotals, type SectionTotals, type UpcomingBlockTotals } from "./read/truncation.ts";
 import { type AreaScopedRead, type ViewFilterMeta } from "./read/area-filter.ts";
 import { type ScopeMeta } from "./read/scope.ts";
-import type { AreaAddParams, AreaUpdateParams, ContainerRef, ProjectCancelParams, OperationKind, OperationParamsMap, ProjectAddParams, ProjectCompleteParams, ProjectAddRepeatingParams, ProjectUpdateParams, RepeatRuleParams, ReorderParams, TagAddParams, TagUpdateParams, HeadingArchiveParams, HeadingUnarchiveParams, HeadingPlacement, TodoAddLoggedParams, TodoAddParams, TodoBackdateParams, TodoMoveParams, TodoUpdateParams } from "./write/operations.ts";
+import type { AreaAddParams, AreaUpdateParams, ContainerRef, ProjectCancelParams, OperationKind, OperationParamsMap, ProjectAddParams, ProjectCompleteParams, ProjectAddRepeatingParams, ProjectUpdateParams, RepeatRuleParams, ReorderParams, TagAddParams, TagUpdateParams, HeadingArchiveParams, HeadingUnarchiveParams, HeadingPlacement, TodoAddParams, TodoMoveParams, TodoUpdateParams } from "./write/operations.ts";
 import { type MutationResult, type WriteOptions } from "./write/pipeline.ts";
 import { type BatchItemResult, type BatchOp, type BatchOptions, type BatchResult } from "./write/batch.ts";
 import { type EnvironmentTracker } from "./write/environment.ts";
@@ -99,33 +101,74 @@ export interface BoundedList<T> {
     filter?: ViewFilterMeta;
 }
 /**
- * A bounded today view: `view` is the shown flat `items[]` (capped in comparator
- * order) plus the whole-view `counts`, and `truncation` the exact counts,
- * including the per-render-section (`today`/`evening`) breakdown — derived per row
- * from `when` — a renderer needs to stay honest.
+ * A bounded Logbook list: the shown logged rows plus the view-level log-move
+ * cadence fact ({@link LogState}) — surfaced as `meta.logging`, rendered as the
+ * card header on a TTY. A sibling of `filter`, never part of the JSON `data`.
+ */
+export interface BoundedLogbook extends BoundedList<ListItem> {
+    logging: LogState;
+}
+/**
+ * A bounded global `upcoming` list: the flat {@link truncateList} slice (rendered
+ * as-is, grouped by day in the renderer) plus `upcomingTotals` — the PRE-cap
+ * per-day-block sizes keyed by `when`, from which each `data.sections` day block's
+ * inline `total` derives (present iff the flat row cap straddled that day, R1).
+ */
+export interface BoundedUpcomingList extends BoundedList<ListItem> {
+    /** Pre-cap day-block sizes for the wire's inline `total` (see {@link UpcomingBlockTotals}). */
+    upcomingTotals: UpcomingBlockTotals;
+}
+/**
+ * A bounded Today view: `view` is the shown split (capped in render order —
+ * Today, then This Evening), `truncation` the exact global counts, and `totals`
+ * the PRE-cap Today/This-Evening bucket sizes — the renderer keeps This Evening
+ * honest under the single global cap, and each `children` bucket's inline `total`
+ * (present iff capped, read-shape v2 R1) derives from them.
  */
 export interface BoundedTodayView {
     view: TodayView;
     truncation: Truncation;
+    /** Pre-cap Today / This-Evening bucket sizes (see {@link TodayBucketTotals}). */
+    totals: TodayBucketTotals;
     /** The active `area` scope, when one was applied (surfaced as `meta.filter`). */
     filter?: ViewFilterMeta;
 }
 /**
  * A bounded sidebar catalogue (anytime/someday): `view` is the
- * per-block-capped sections and `truncation` the unified completeness metadata
- * whose `blocks` carry the identity-bearing per-block counts (project blocks
- * nested under their area/loose block).
+ * per-block-capped sections and `truncation` the WHOLE-VIEW completeness rollup
+ * (`{shown,total,limit,truncated}`). Per-section completeness rides its inline
+ * `total` on the wire (stamped from `sectionTotals`, R1); `blocks` carries the
+ * identity-bearing per-block counts (project blocks nested under their area/loose
+ * block) as INTERNAL render plumbing only — the grouped renderers' "… N more"
+ * drill-downs — never on the wire (doctrine v2 PR 5: the sidecar retired).
  */
 export interface BoundedSectionsView {
     view: SidebarSection[];
     truncation: Truncation;
+    /** Per-block render detail (TTY drill-downs); never serialized. */
+    blocks: GroupBlock[];
+    /**
+     * Pre-cap per-section sizes keyed by area uuid (`null` = loose) — the inline
+     * `total` a consumer stamps on each capped section ({@link withSectionTotals},
+     * R1), so completeness is answerable locally with no `blocks[]` sidecar.
+     */
+    sectionTotals: SectionTotals;
     /** The active `area` scope, when one was applied (surfaced as `meta.filter`). */
     filter?: ViewFilterMeta;
 }
-/** A bounded composite area card: the per-section-capped view and the per-block truncation. */
+/** A bounded composite area card: the per-section-capped view and the whole-view rollup. */
 export interface BoundedAreaView {
     view: AreaView;
     truncation: Truncation;
+    /** Per-block render detail (the `area show` "… N more" footers); never serialized. */
+    blocks: GroupBlock[];
+    /**
+     * Pre-cap scope sizes (read-shape v2 R1, PR 3) — the direct-to-dos and
+     * project-rows counts a consumer stamps as each capped scope's inline `total`
+     * ({@link withAreaBucketTotals}), so completeness is answerable locally with no
+     * `meta.truncation.blocks[]` sidecar.
+     */
+    totals: AreaBucketTotals;
     /**
      * A resolution disclosure — present ONLY on the `loose` pseudo-area read when
      * a real area shadows the reserved word (names it, by uuid, for targeting).
@@ -141,6 +184,16 @@ export interface BoundedAreaView {
      */
     loggedCount?: number;
 }
+/**
+ * Resolution-timestamp flags (plan §2): an ISO date (`2025-01-15`) or datetime
+ * (`2025-01-15T09:30`). `completedAt` sets the completion timestamp (also the
+ * "Completed on" stamp for canceled items); `createdAt` backdates creation. A
+ * date-only value normalizes to noon in the effective zone (§5).
+ */
+export interface ResolutionDates {
+    createdAt?: string;
+    completedAt?: string;
+}
 export interface ThingsClient {
     dbPath: string;
     config: ThingsApiConfig;
@@ -192,11 +245,11 @@ export interface ThingsClient {
     refPromoter(): RefPromoter;
     read: {
         /**
-         * The Today list — one flat `items[]` of Today members (Today-proper and
-         * This-Evening interleaved in comparator order, each row's `when` carrying
-         * which) plus the whole-view `counts` aggregate, bounded to `limit` rows
-         * (default 50). `all`/`limit: null` returns every row; the `truncation`
-         * metadata carries the per-render-section (`today`/`evening`) counts.
+         * The Today list (Today + This Evening split) plus the whole-view `counts`
+         * aggregate (the app's sidebar count), bounded to `limit` rows (default 50)
+         * counted in render order — Today first, then This Evening. `all`/`limit:
+         * null` returns every row; `totals` carries the pre-cap Today/This-Evening
+         * bucket sizes (the two `children` bucket records project from the split).
          */
         today(options?: TodayFilter & ListBound & ClockScopedRead & AreaScopedRead): BoundedTodayView;
         /** Inbox captures, bounded (default 50). */
@@ -208,8 +261,8 @@ export interface ThingsClient {
          * catalogue to one area (its rows survive; the rest drop).
          */
         anytime(options?: ViewFilter & GroupedBound & ClockScopedRead & AreaScopedRead): BoundedSectionsView;
-        /** Future-scheduled items in date order, bounded (default 50). */
-        upcoming(options?: UpcomingFilter & ListBound & ClockScopedRead & AreaScopedRead): BoundedList<ListItem>;
+        /** Future-scheduled items in date order, bounded (default 50); day-block totals for R1. */
+        upcoming(options?: UpcomingFilter & ListBound & ClockScopedRead & AreaScopedRead): BoundedUpcomingList;
         /**
          * Someday catalogue: `areaLimit` (default 30) caps each group; with
          * `activeProjectItems`, `projectLimit` (default: every item) caps each
@@ -217,8 +270,13 @@ export interface ThingsClient {
          * the catalogue to one area.
          */
         someday(options?: SomedayFilter & GroupedBound & ClockScopedRead & AreaScopedRead): BoundedSectionsView;
-        /** Logbook entries (most recent first), bounded (default 50). */
-        logbook(options?: Omit<LogbookFilter, "limit"> & ListBound & ClockScopedRead): BoundedList<ListItem>;
+        /**
+         * Logbook entries (most recent first), bounded (default 50), plus the
+         * view-level log-move cadence fact ({@link LogState}) surfaced as
+         * `meta.logging` — the "Move completed items to Logbook" setting in CC's own
+         * words, and the last-logged instant under Manually.
+         */
+        logbook(options?: Omit<LogbookFilter, "limit"> & ListBound & ClockScopedRead): BoundedLogbook;
         /** Trashed items (most recently modified first), bounded (default 50). */
         trash(options?: ListBound & ClockScopedRead): BoundedList<ListItem>;
         /**
@@ -268,6 +326,16 @@ export interface ThingsClient {
         changes(options: {
             since: Date;
         } & ListBound & ClockScopedRead): BoundedList<ChangedItem>;
+        /**
+         * The deadline-horizon view: every live to-do AND project carrying a
+         * deadline, ordered deadline ASC (most-overdue first), then todayIndex, then
+         * uuid; deadline-bearing repeating templates project at their next
+         * occurrence's deadline. Bounded (default 50). `todayOnly` restricts to
+         * current Today members (evening-inclusive); `overdue` keeps only open,
+         * past-deadline rows (and excludes projections); `project`/`area` scope to a
+         * container; the tag filters compose.
+         */
+        deadlines(options?: DeadlinesFilter & ListBound & ClockScopedRead): BoundedList<ListItem>;
         byUuid(uuid: string): AnyTask | null;
         /**
          * Classify a loose reference (uuid, >=6-char prefix, share link, or
@@ -281,9 +349,20 @@ export interface ThingsClient {
         /** Generic entry: run any cataloged operation. */
         run<K extends OperationKind>(op: K, params: OperationParamsMap[K], options?: WriteOptions): Promise<MutationResult>;
         addTodo(params: TodoAddParams, options?: WriteOptions): Promise<MutationResult>;
-        updateTodo(uuid: string, patch: Omit<TodoUpdateParams, "uuid">, options?: WriteOptions): Promise<MutationResult>;
-        completeTodo(uuid: string, options?: WriteOptions): Promise<MutationResult>;
-        cancelTodo(uuid: string, options?: WriteOptions): Promise<MutationResult>;
+        updateTodo(uuid: string, patch: Omit<TodoUpdateParams, "uuid"> & ResolutionDates, options?: WriteOptions): Promise<MutationResult>;
+        /**
+         * Complete a to-do. With `resolution.completedAt` (ISO date or datetime) the
+         * to-do lands completed and BACKDATED — resolving it first if needed, then
+         * an AppleScript completion-date write; a date-only value normalizes to noon
+         * in the effective zone (§5). Multi-leg, disclosed in the result / dry-run.
+         */
+        completeTodo(uuid: string, resolution?: ResolutionDates, options?: WriteOptions): Promise<MutationResult>;
+        /**
+         * Cancel a to-do. With `resolution.completedAt` it lands canceled and
+         * BACKDATED via the certified flip-dance (→completed · AS backdate · →canceled)
+         * — the only headless path that keeps a canceled item canceled.
+         */
+        cancelTodo(uuid: string, resolution?: ResolutionDates, options?: WriteOptions): Promise<MutationResult>;
         reopenTodo(uuid: string, options?: WriteOptions): Promise<MutationResult>;
         moveTodo(uuid: string, dest: Omit<TodoMoveParams, "uuid">, options?: WriteOptions): Promise<MutationResult>;
         /**
@@ -303,6 +382,18 @@ export interface ThingsClient {
          * fail closed.
          */
         reorderTodos(request: ReorderRequest, options?: WriteOptions): Promise<MoveResult>;
+        /**
+         * The ONE reorder verb (`things reorder`). Rearranges a single-KIND set IN
+         * PLACE — to-dos, projects, headings, OR sidebar areas — dispatching the
+         * protocol by kind: the index/day/view engine for to-dos and projects (a
+         * to-do+project set intermixes only on the shared Today/Evening/day axes), the
+         * certified heading-block wire for a project's headings (archived headings
+         * reorderable, reopens disclosed — #V11), and the sidebar-drag driver for
+         * areas. A mixed-kind set, a cross-container set, and a non-member anchor each
+         * get one precise refusal. Bare (no position) assembles the block at the
+         * earliest movee's slot; --start/--end/--before/--after position it.
+         */
+        reorderAny(request: ReorderRequest, options?: WriteOptions): Promise<MoveResult>;
         /** Replace the full tag set (an empty list clears all tags). */
         setTags(uuid: string, tags: string[], options?: WriteOptions): Promise<MutationResult>;
         /** Merge: current direct tags + new ones, then replace. */
@@ -321,17 +412,6 @@ export interface ThingsClient {
          * Reversible with `undo`. Force a path with `vector: "shortcuts" | "url-scheme"`.
          */
         clearReminder(uuid: string, options?: WriteOptions): Promise<MutationResult>;
-        /**
-         * Rewrite a to-do's completion and/or creation timestamp to noon (local)
-         * on the given date. Completion requires the to-do to be completed or
-         * canceled already.
-         */
-        backdateTodo(uuid: string, dates: Omit<TodoBackdateParams, "uuid">, options?: WriteOptions): Promise<MutationResult>;
-        /**
-         * Create a to-do directly in the Logbook, completed, with backdated
-         * completion (and optionally creation) timestamps.
-         */
-        addLoggedTodo(params: TodoAddLoggedParams, options?: WriteOptions): Promise<MutationResult>;
         /**
          * Create a heading inside an EXISTING project; the new heading's uuid is
          * on the result. Delivered through the Things proxy shortcuts (run
@@ -391,8 +471,9 @@ export interface ThingsClient {
          */
         editChecklist(uuid: string, edit: ChecklistEdit, options?: WriteOptions): Promise<MutationResult>;
         addProject(params: ProjectAddParams, options?: WriteOptions): Promise<MutationResult>;
-        updateProject(uuid: string, patch: Omit<ProjectUpdateParams, "uuid">, options?: WriteOptions): Promise<MutationResult>;
-        completeProject(uuid: string, policy: Pick<ProjectCompleteParams, "children">, options?: WriteOptions): Promise<MutationResult>;
+        updateProject(uuid: string, patch: Omit<ProjectUpdateParams, "uuid"> & ResolutionDates, options?: WriteOptions): Promise<MutationResult>;
+        /** Complete a project; `resolution.completedAt` backdates it (see completeTodo). */
+        completeProject(uuid: string, policy: Pick<ProjectCompleteParams, "children"> & ResolutionDates, options?: WriteOptions): Promise<MutationResult>;
         /** Move a project to another area. */
         moveProject(uuid: string, area: ContainerRef, options?: WriteOptions): Promise<MutationResult>;
         /** Detach a project from its current area. */
@@ -405,8 +486,8 @@ export interface ThingsClient {
         moveProjects(request: ProjectMoveRequest, options?: WriteOptions): Promise<MoveResult>;
         /** Reorder projects IN PLACE among their siblings (spec §4). */
         reorderProjects(request: ReorderRequest, options?: WriteOptions): Promise<MoveResult>;
-        /** Cancel a project — open children are canceled with it, so the children policy is mandatory. */
-        cancelProject(uuid: string, policy: Pick<ProjectCancelParams, "children">, options?: WriteOptions): Promise<MutationResult>;
+        /** Cancel a project — open children are canceled with it, so the children policy is mandatory. `resolution.completedAt` backdates it (flip-dance). */
+        cancelProject(uuid: string, policy: Pick<ProjectCancelParams, "children"> & ResolutionDates, options?: WriteOptions): Promise<MutationResult>;
         /**
          * Reopen a completed/canceled project. Children stay resolved unless
          * restoreChildren reopens the ones resolved together with the project.
@@ -446,6 +527,14 @@ export interface ThingsClient {
         updateTag(target: string, patch: Omit<TagUpdateParams, "target">, options?: WriteOptions): Promise<MutationResult>;
         deleteTag(target: string, options?: WriteOptions): Promise<MutationResult>;
         emptyTrash(options?: WriteOptions): Promise<MutationResult>;
+        /**
+         * Move completed items into the Logbook now (`log completed now`). The result
+         * discloses how many items were logged (`observed.logged`); when nothing is
+         * pending it is a clean no-op (`logged: 0`, not an error). IRREVERSIBLE — the
+         * log-move boundary cannot be rewound by any official surface, so no undo token
+         * is emitted.
+         */
+        logNow(options?: WriteOptions): Promise<MutationResult>;
         /**
          * Reorder within Today / This Evening / a project / an area. Partial
          * uuid lists are placed on top; the rest keep their current order.

package/dist/client.js

@@ -11,12 +11,13 @@ import { byUuid } from "./read/detail.js";
 import { makeRefPromoter, resolveAreaUuid, resolveHeadingUuid, resolveProjectUuid, resolveTaskUuidPrefix, } from "./read/queries.js";
 import { areaView } from "./read/area-view.js";
 import { isLooseRef, looseShadowNotice, shadowingLooseArea } from "./read/pseudo-area.js";
+import { logState } from "./read/log-boundary.js";
 import { projectView } from "./read/project-view.js";
 import { snapshotView } from "./read/snapshot.js";
 import { classifyShowTarget } from "./read/show-target.js";
 import { areasView, tagsView } from "./read/tags.js";
-import { anytimeView, areaLoggedCount, changesView, inboxView, liteTitleSearch, logbookView, projectsView, searchView, somedayView, todayView, trashView, upcomingView, } from "./read/views.js";
-import { capAreaSections, previewSections, previewSomedaySections, truncateList, truncateToday, } from "./read/truncation.js";
+import { anytimeView, areaLoggedCount, changesView, deadlinesView, inboxView, liteTitleSearch, logbookView, projectsView, searchView, somedayView, todayView, trashView, upcomingView, } from "./read/views.js";
+import { capAreaSections, previewSections, previewSomedaySections, truncateList, truncateToday, upcomingBlockTotals, } from "./read/truncation.js";
 import { filterListByArea, filterSectionsByArea, filterTodayByArea, resolveAreaFilter, } from "./read/area-filter.js";
 import { filterListByScope, filterSectionsByScope, filterTodayByScope, inScopeItem, namedAreaClause, namedProjectClause, resolveScope, scopeMeta, taskMembershipClause, } from "./read/scope.js";
 import { localToday } from "./model/dates.js";
@@ -31,8 +32,9 @@ import { runAddHeading, runHeadingArchive, runHeadingUnarchive, } from "./write/
 import { runClearReminder } from "./write/clear-reminder.js";
 import { runEditChecklist } from "./write/edit-checklist.js";
 import { runAddRepeatingProject, runMakeRepeatingProject } from "./write/make-repeating-project.js";
+import { runCancelWithDate, runCompleteWithDate, runUpdateDates, } from "./write/resolution-timestamps.js";
 import { runReorder } from "./write/reorder.js";
-import { runInPlaceReorder, runProjectMove, runTodoMove, } from "./write/move.js";
+import { runInPlaceReorder, runProjectMove, runTodoMove, runUniversalReorder, } from "./write/move.js";
 import { readAuditRecords, runUndo } from "./write/undo.js";
 import { runProjectReopen, } from "./write/reopen.js";
 import { defaultVectors } from "./write/vectors/registry.js";
@@ -182,6 +184,26 @@ export function openThings(options = {}) {
         // to the effective zone before dispatch (a no-op without a zone).
         return runMutation(writeDeps, op, params, { ...writeOptions, normalizeWhen: true });
     };
+    // update dispatcher: the resolution-timestamp flags route through the
+    // multi-leg orchestrator; plain attribute edits stay on `todo/project.update`.
+    // When BOTH are present the attribute edit lands first (its own undo), then
+    // the timestamp legs — two independently-undoable changes.
+    const runUpdate = async (kind, uuid, patch, o) => {
+        const { createdAt, completedAt, ...attrs } = patch;
+        const op = kind === "project" ? "project.update" : "todo.update";
+        if (createdAt === undefined && completedAt === undefined) {
+            return run(op, { uuid, ...attrs }, o);
+        }
+        if (Object.keys(attrs).length > 0) {
+            const attrResult = await run(op, { uuid, ...attrs }, o);
+            if (attrResult.kind !== "ok" && attrResult.kind !== "dry-run")
+                return attrResult;
+        }
+        return runUpdateDates(writeDeps, kind, uuid, {
+            ...(createdAt !== undefined && { createdAt }),
+            ...(completedAt !== undefined && { completedAt }),
+        }, o ?? {});
+    };
     return {
         dbPath: located.path,
         config,
@@ -227,8 +249,8 @@ export function openThings(options = {}) {
                     view = filterTodayByArea(view, target.uuid, localToday(now(), zoneOf(o)));
                     filter = { area: target };
                 }
-                const { data, truncation } = truncateToday(view, listCap(o));
-                return { view: data, truncation, ...(filter !== undefined && { filter }) };
+                const { data, truncation, totals } = truncateToday(view, listCap(o));
+                return { view: data, truncation, totals, ...(filter !== undefined && { filter }) };
             },
             inbox: (o) => {
                 let items = inboxView(conn.db, now(), o, zoneOf(o));
@@ -249,8 +271,14 @@ export function openThings(options = {}) {
                     sections = filterSectionsByArea(sections, target.uuid);
                     filter = { area: target };
                 }
-                const { data, truncation } = previewSections(sections, groupedCaps(o, AREA_PREVIEW_LIMIT, PROJECT_PREVIEW_LIMIT));
-                return { view: data, truncation, ...(filter !== undefined && { filter }) };
+                const { data, truncation, blocks, totals } = previewSections(sections, groupedCaps(o, AREA_PREVIEW_LIMIT, PROJECT_PREVIEW_LIMIT));
+                return {
+                    view: data,
+                    truncation,
+                    blocks,
+                    sectionTotals: totals,
+                    ...(filter !== undefined && { filter }),
+                };
             },
             upcoming: (o) => {
                 let items = upcomingView(conn.db, now(), o, zoneOf(o));
@@ -262,8 +290,11 @@ export function openThings(options = {}) {
                     items = filterListByArea(items, target.uuid);
                     filter = { area: target };
                 }
+                // Pre-cap per-day-block sizes for the wire's inline `total` (R1): counted
+                // over the in-scope, area-filtered stream BEFORE the flat row cap slices it.
+                const upcomingTotals = upcomingBlockTotals(items);
                 const { data, truncation } = truncateList(items, listCap(o));
-                return { items: data, truncation, ...(filter !== undefined && { filter }) };
+                return { items: data, truncation, upcomingTotals, ...(filter !== undefined && { filter }) };
             },
             someday: (o) => {
                 let sections = somedayView(conn.db, now(), o, zoneOf(o));
@@ -275,8 +306,14 @@ export function openThings(options = {}) {
                     sections = filterSectionsByArea(sections, target.uuid);
                     filter = { area: target };
                 }
-                const { data, truncation } = previewSomedaySections(sections, groupedCaps(o, AREA_PREVIEW_LIMIT, null));
-                return { view: data, truncation, ...(filter !== undefined && { filter }) };
+                const { data, truncation, blocks, totals } = previewSomedaySections(sections, groupedCaps(o, AREA_PREVIEW_LIMIT, null));
+                return {
+                    view: data,
+                    truncation,
+                    blocks,
+                    sectionTotals: totals,
+                    ...(filter !== undefined && { filter }),
+                };
             },
             logbook: (o) => {
                 // The bound is the truncation cap; the underlying query stays unbounded
@@ -293,7 +330,12 @@ export function openThings(options = {}) {
                 // only resolves the target for the additive `filter` annotation so the
                 // meta shape matches the post-filtered views.
                 const areaFilter = o?.area !== undefined ? { area: areaFilterTarget(o.area) } : undefined;
-                return { items: data, truncation, ...(areaFilter !== undefined && { filter: areaFilter }) };
+                return {
+                    items: data,
+                    truncation,
+                    logging: logState(conn.db),
+                    ...(areaFilter !== undefined && { filter: areaFilter }),
+                };
             },
             trash: (o) => {
                 let items = trashView(conn.db, now(), { limit: null }, zoneOf(o));
@@ -340,7 +382,7 @@ export function openThings(options = {}) {
                         : { where: "0", binds: [] };
                     resolveAreaUuid(conn.db, ref, { scopeWhere: clause.where, scopeBinds: clause.binds });
                 }
-                const { data, truncation } = capAreaSections(areaView(conn.db, ref, now(), o ?? {}, zoneOf(o)), groupedCaps(o, AREA_PREVIEW_LIMIT, AREA_PREVIEW_LIMIT), now(), zoneOf(o));
+                const { data, truncation, blocks, totals } = capAreaSections(areaView(conn.db, ref, now(), o ?? {}, zoneOf(o)), groupedCaps(o, AREA_PREVIEW_LIMIT, AREA_PREVIEW_LIMIT), now(), zoneOf(o));
                 // Reserved-word disclosure: `loose` ALWAYS wins over a real area named
                 // "Loose"; when one shadows, name it (by uuid) so it stays targetable.
                 const shadow = isLooseRef(ref) ? shadowingLooseArea(conn.db) : undefined;
@@ -353,6 +395,8 @@ export function openThings(options = {}) {
                 return {
                     view: data,
                     truncation,
+                    blocks,
+                    totals,
                     ...(shadow !== undefined && { notice: looseShadowNotice(shadow) }),
                     ...(loggedCount !== undefined && { loggedCount }),
                 };
@@ -396,11 +440,25 @@ export function openThings(options = {}) {
                 const { data, truncation } = truncateList(items, listCap(o));
                 return { items: data, truncation };
             },
+            deadlines: (o) => {
+                const { limit: _limit, ...filter } = o ?? {};
+                // The view is computed UNBOUNDED (project/area/tag/overdue/today scoping
+                // happens inside it); the whole-view truncation is applied here so the
+                // total behind the cut is honest.
+                let items = deadlinesView(conn.db, now(), filter, zoneOf(o));
+                // A container jail is an additive post-filter (parity with search): keep
+                // only in-scope rows so an out-of-scope deadline never leaks.
+                if (scope !== undefined)
+                    items = items.filter((i) => inScopeItem(i, scope));
+                const { data, truncation } = truncateList(items, listCap(o));
+                return { items: data, truncation };
+            },
             showTarget: (ref) => classifyShowTarget(conn.db, ref, scope),
             byUuid: (uuid) => {
                 // Prefix-friendly: unknown refs keep the null contract; ambiguity throws.
-                // The injected clock gates `todaySection` to Today members under the
-                // consumer's own today (a pinned-clock/lab run reads honestly). Under a
+                // The injected clock gates the today/evening markers (and reminder
+                // liveness) under the consumer's own today (a pinned-clock/lab run reads
+                // honestly). Under a
                 // scope, an out-of-scope uuid resolves to not-found → null (parity).
                 try {
                     return byUuid(conn.db, resolveTaskUuidPrefix(conn.db, uuid, "to-do", scopeClauses?.task), now(), defaultZone);
@@ -423,13 +481,14 @@ export function openThings(options = {}) {
         write: {
             run,
             addTodo: (params, o) => run("todo.add", params, o),
-            updateTodo: (uuid, patch, o) => run("todo.update", { uuid, ...patch }, o),
-            completeTodo: (uuid, o) => run("todo.complete", { uuid }, o),
-            cancelTodo: (uuid, o) => run("todo.cancel", { uuid }, o),
+            updateTodo: (uuid, patch, o) => runUpdate("todo", uuid, patch, o),
+            completeTodo: (uuid, resolution, o) => runCompleteWithDate(writeDeps, "todo", uuid, resolution ?? {}, o ?? {}),
+            cancelTodo: (uuid, resolution, o) => runCancelWithDate(writeDeps, "todo", uuid, resolution ?? {}, o ?? {}),
             reopenTodo: (uuid, o) => run("todo.reopen", { uuid }, o),
             moveTodo: (uuid, dest, o) => run("todo.move", { uuid, ...dest }, o),
             moveTodos: (request, o) => runTodoMove(writeDeps, request, o ?? {}),
             reorderTodos: (request, o) => runInPlaceReorder(writeDeps, "todo.move", request, o ?? {}),
+            reorderAny: (request, o) => runUniversalReorder(writeDeps, request, o ?? {}),
             setTags: (uuid, tags, o) => run("todo.set-tags", { uuid, tags }, o),
             addTags(uuid, tags, o) {
                 const current = byUuid(conn.db, uuid);
@@ -441,8 +500,6 @@ export function openThings(options = {}) {
             deleteTodo: (uuid, o) => run("todo.delete", { uuid }, o),
             duplicateTodo: (uuid, o) => run("todo.duplicate", { uuid }, o),
             restoreTodo: (uuid, o) => run("todo.restore", { uuid }, o),
-            backdateTodo: (uuid, dates, o) => run("todo.backdate", { uuid, ...dates }, o),
-            addLoggedTodo: (params, o) => run("todo.add-logged", params, o),
             addHeading: (project, title, placement, o) => runAddHeading(writeDeps, project, title, placement, o ?? {}),
             renameHeading: (uuid, title, o) => run("project.rename-heading", { uuid, title }, o),
             moveHeading: (project, headings, placement, o) => run("project.move-heading", { project, headings, placement }, o),
@@ -454,13 +511,19 @@ export function openThings(options = {}) {
             detachTodo: (uuid, o) => run("todo.move", { uuid, loose: true }, o),
             editChecklist: (uuid, edit, o) => runEditChecklist(writeDeps, uuid, edit, o ?? {}),
             addProject: (params, o) => run("project.add", params, o),
-            updateProject: (uuid, patch, o) => run("project.update", { uuid, ...patch }, o),
-            completeProject: (uuid, policy, o) => run("project.complete", { uuid, children: policy.children }, o),
+            updateProject: (uuid, patch, o) => runUpdate("project", uuid, patch, o),
+            completeProject: (uuid, policy, o) => runCompleteWithDate(writeDeps, "project", uuid, {
+                children: policy.children,
+                ...(policy.completedAt !== undefined && { completedAt: policy.completedAt }),
+            }, o ?? {}),
             moveProject: (uuid, area, o) => run("project.move", { uuid, area }, o),
             detachProject: (uuid, o) => run("project.move", { uuid, noArea: true }, o),
             moveProjects: (request, o) => runProjectMove(writeDeps, request, o ?? {}),
             reorderProjects: (request, o) => runInPlaceReorder(writeDeps, "project.move", request, o ?? {}),
-            cancelProject: (uuid, policy, o) => run("project.cancel", { uuid, children: policy.children }, o),
+            cancelProject: (uuid, policy, o) => runCancelWithDate(writeDeps, "project", uuid, {
+                children: policy.children,
+                ...(policy.completedAt !== undefined && { completedAt: policy.completedAt }),
+            }, o ?? {}),
             reopenProject: (uuid, o) => runProjectReopen(writeDeps, uuid, o ?? {}),
             restoreProject: (uuid, o) => run("project.restore", { uuid }, o),
             duplicateProject: (uuid, o) => run("project.duplicate", { uuid }, o),
@@ -481,6 +544,7 @@ export function openThings(options = {}) {
             updateTag: (target, patch, o) => run("tag.update", { target, ...patch }, o),
             deleteTag: (target, o) => run("tag.delete", { target }, o),
             emptyTrash: (o) => run("trash.empty", {}, o),
+            logNow: (o) => run("log-now", {}, o),
             reorder: (params, o) => runReorder(writeDeps, params, o ?? {}),
             batch: (ops, o, onResult) => runBatch(writeDeps, ops, o ?? {}, onResult),
             undo: (o, onItem) => runUndo(writeDeps, auditDir(env), o ?? {}, onItem),