things-api 0.14.0 → 0.16.0

package/dist/write/commands.js

@@ -1,5 +1,6 @@
 import { decodeReminderTime, encodeReminderTime, localToday, reminderUrlToken, zonedWallInstant, } from "../model/dates.js";
 import { byUuid } from "../read/detail.js";
+import { manualLogDateEpoch, pendingLogCount } from "../read/log-boundary.js";
 import { isLooseRef } from "../read/pseudo-area.js";
 import { reminderIsLive } from "../read/stage.js";
 import { areaMemberCounts, childTagTitles, classifyHeadingConvert, classifyHeadingDissolve, classifyHeadingMoveToProject, classifyProjectRepeat, computeHeadingMovePre, computeReorderPre, emptyPreState, loadTarget, projectChildren, projectStatus, projectSubtreeUuids, resolveArea, resolveHeading, resolveProject, resolveTag, sameTitleTaskUuids, trashedCount, } from "./pre-state.js";
@@ -62,7 +63,7 @@ function q(value) {
 function unsupportedVector(op, vector) {
     throw new Error(`${op} cannot be compiled for vector ${vector} (planner bug)`);
 }
-function whenAssertions(when, todayIso) {
+function whenAssertions(when, todayIso, opts = { mode: "add" }) {
     // Strict shape check: an unvalidated string used to flow straight into the
     // URL (e.g. "2026-07-20@09:30", the raw URL grammar) — the app would SET
     // date+reminder while verification asserted the literal string as the date,
@@ -78,16 +79,35 @@ function whenAssertions(when, todayIso) {
     }
     switch (when) {
         case "today":
+            // Today's non-evening section: in Today (the `today` marker) AND NOT in the
+            // evening sub-bucket (the presence-keyed `evening` marker absent — asserted
+            // as null, which valuesEqual treats as absent). Gated to Today members under
+            // the verify clock exactly as the retired `todaySection` was.
+            //
+            // The `startDate` assertion differs by op (field bug §0½.8):
+            //  - ADD mints a fresh Today item with no schedule history, so the app dates
+            //    it EXACTLY today — exact equality is right.
+            //  - UPDATE of an item ALREADY in Today whose `startDate` has already arrived
+            //    (past or today): the app PRESERVES that historical date rather than
+            //    rewriting the storage byte to today (arrived-date law). Assert the
+            //    arrived-date PREDICATE (non-null and <= today) so a preserved historical
+            //    date verifies, while an undated deadline-only pull (null startDate) is
+            //    still rejected — the item's Today membership then rests only on a
+            //    deadline, not on the requested schedule.
             return [
                 { field: "start", equals: "active" },
-                { field: "startDate", equals: todayIso },
-                { field: "todaySection", equals: "today" },
+                opts.mode === "update"
+                    ? { field: "startDate", satisfies: { predicate: "arrived-on-or-before", date: todayIso } }
+                    : { field: "startDate", equals: todayIso },
+                { field: "today", equals: true },
+                { field: "evening", equals: null },
             ];
         case "evening":
+            // The This-Evening sub-bucket: the `evening` marker (which implies `today`).
             return [
                 { field: "start", equals: "active" },
                 { field: "startDate", equals: todayIso },
-                { field: "todaySection", equals: "evening" },
+                { field: "evening", equals: true },
             ];
         case "anytime":
             return [
@@ -304,8 +324,11 @@ const todoAdd = {
             }
             if (params.tags !== undefined)
                 attrs["tags"] = pre.resolvedTagTitles;
-            if (params.checklistItems !== undefined)
-                attrs["checklist-items"] = params.checklistItems;
+            if (params.checklistItems !== undefined) {
+                // §9y: things:///json rejects a bare STRING array wholesale (silent
+                // no-op) — emit the OBJECT-array shape the app accepts.
+                attrs["checklist-items"] = checklistItemsJsonAttr(params.checklistItems.map((title) => ({ title })));
+            }
             if (container?.uuid !== undefined)
                 attrs["list-id"] = container.uuid;
             if (pre.destHeading?.resolved?.title !== undefined) {
@@ -353,7 +376,12 @@ function effectiveReminder(pre, params) {
         return null;
     if (!reminderIsLive(target.startDate, pre.todayIso))
         return null;
-    return target.reminder;
+    // Read the RAW stored byte off the substrate (top-level `reminder` is
+    // live-gated under the LOAD clock, which can differ from `pre.todayIso` under a
+    // pinned THINGS_NOW). The `reminderIsLive` guard above applies liveness under
+    // the injected clock explicitly, so the raw byte + this gate reproduce the
+    // former semantics exactly.
+    return target.derived.reminder;
 }
 function assertNotesModesExclusive(params) {
     if (params.notes !== undefined &&
@@ -396,7 +424,7 @@ const todoUpdate = {
         if (joined !== undefined)
             assert.push({ field: "notes", equals: joined });
         if (params.when !== undefined) {
-            assert.push(...whenAssertions(params.when, ctx.todayIso));
+            assert.push(...whenAssertions(params.when, ctx.todayIso, { mode: "update" }));
             const reminder = effectiveReminder(pre, params);
             assert.push({
                 field: "reminder",
@@ -601,6 +629,48 @@ const todoSetTags = {
     },
 };
 /** Normalize the string | spec union; decide whether states force the json form. */
+/**
+ * The `checklist-items` value `things:///json` accepts: an array of
+ * `{type:"checklist-item",attributes:{title[,completed]}}` OBJECTS. A bare
+ * STRING array is rejected wholesale — the whole import silently no-ops, no row,
+ * no error (§9y; RESID1 R-JSONPAR RAW-a..d). `completed` is emitted only when a
+ * spec carries it, so an at-creation add (all items open) yields the minimal
+ * `{title}` attributes the probe validated (OBJ/OBJ3), while the checklist
+ * replace path forwards its per-item state.
+ */
+function checklistItemsJsonAttr(specs) {
+    return specs.map((s) => ({
+        type: "checklist-item",
+        attributes: s.completed === undefined ? { title: s.title } : { title: s.title, completed: s.completed },
+    }));
+}
+/**
+ * Build a project json import's `items` array from a structured
+ * {@link ProjectItemSpec} list (the clone / rich-import path). Order IS the
+ * layout: a `heading` node produces a `{type:"heading"}` row and every following
+ * `to-do` node inherits it positionally (A4); a `to-do` before the first heading
+ * is a project-root child. Children are born OPEN — no `completed` attribute.
+ */
+function projectItemsJsonAttr(items) {
+    return items.map((it) => {
+        if (it.kind === "heading") {
+            return { type: "heading", attributes: { title: it.title } };
+        }
+        const attrs = { title: it.title };
+        if (it.notes !== undefined)
+            attrs["notes"] = it.notes;
+        if (it.when !== undefined)
+            attrs["when"] = it.when;
+        if (it.deadline !== undefined)
+            attrs["deadline"] = it.deadline;
+        if (it.tags !== undefined)
+            attrs["tags"] = it.tags;
+        if (it.checklistItems !== undefined) {
+            attrs["checklist-items"] = checklistItemsJsonAttr(it.checklistItems.map((title) => ({ title })));
+        }
+        return { type: "to-do", attributes: attrs };
+    });
+}
 function checklistSpecs(items) {
     const specs = items.map((i) => typeof i === "string"
         ? { title: i, completed: false }
@@ -647,10 +717,7 @@ const todoReplaceChecklist = {
                 operation: "update",
                 id: params.uuid,
                 attributes: {
-                    "checklist-items": specs.map((s) => ({
-                        type: "checklist-item",
-                        attributes: { title: s.title, completed: s.completed },
-                    })),
+                    "checklist-items": checklistItemsJsonAttr(specs),
                 },
             },
         ]);
@@ -675,6 +742,28 @@ const todoEditChecklistItem = {
         throw new Error(ORCHESTRATED_ONLY);
     },
 };
+const CLONE_ORCHESTRATED_ONLY = "todo.clone / project.clone are delivered by the runCloneTodo / runCloneProject orchestrators (a " +
+    "compound over todo.add / project.add plus checklist / terminal-state follow-up legs); they have " +
+    "no atomic surface and are never dispatched directly through the pipeline";
+function cloneStub(op) {
+    return {
+        op,
+        hazards: [],
+        preRead(db, params) {
+            const pre = emptyPreState();
+            pre.target = loadTarget(db, params.uuid);
+            return pre;
+        },
+        expectedDelta() {
+            throw new Error(CLONE_ORCHESTRATED_ONLY);
+        },
+        compile() {
+            throw new Error(CLONE_ORCHESTRATED_ONLY);
+        },
+    };
+}
+const todoClone = cloneStub("todo.clone");
+const projectClone = cloneStub("project.clone");
 const todoDelete = {
     op: "todo.delete",
     hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
@@ -704,6 +793,13 @@ const projectAdd = {
             throw new RangeError("--completed-at cannot seed child to-dos: a completed-project import reverts to open " +
                 "unless every child is resolved (§5b) — create the project resolved, then add logged children");
         }
+        if (params.todos !== undefined && params.items !== undefined) {
+            throw new RangeError("project.add takes either `todos` or structured `items`, not both");
+        }
+        if (params.completedAt !== undefined && params.items !== undefined && params.items.length > 0) {
+            throw new RangeError("--completed-at cannot seed child items: a completed-project import reverts to open " +
+                "unless every child is resolved (§5b)");
+        }
         const pre = emptyPreState();
         if (containerGiven(params.area))
             pre.destArea = resolveArea(db, params.area);
@@ -739,7 +835,9 @@ const projectAdd = {
     compile(params, vector, pre, ctx) {
         if (vector !== "url-scheme")
             unsupportedVector(this.op, vector);
-        if (addHasTimestamps(params)) {
+        // The json import is required for born-timestamps AND for structured `items`
+        // (headings / rich children) — the plain add-project URL carries neither.
+        if (addHasTimestamps(params) || params.items !== undefined) {
             const attrs = { title: params.title };
             if (params.notes !== undefined)
                 attrs["notes"] = params.notes;
@@ -749,7 +847,10 @@ const projectAdd = {
                     attrs["when"] = params.when;
                 if (params.deadline !== undefined)
                     attrs["deadline"] = params.deadline;
-                if (params.todos !== undefined) {
+                if (params.items !== undefined) {
+                    attrs["items"] = projectItemsJsonAttr(params.items);
+                }
+                else if (params.todos !== undefined) {
                     attrs["items"] = params.todos.map((t) => ({ type: "to-do", attributes: { title: t } }));
                 }
             }
@@ -787,7 +888,7 @@ const projectUpdate = {
         if (joined !== undefined)
             assert.push({ field: "notes", equals: joined });
         if (params.when !== undefined) {
-            assert.push(...whenAssertions(params.when, ctx.todayIso));
+            assert.push(...whenAssertions(params.when, ctx.todayIso, { mode: "update" }));
             // Projects carry the same reminderTime codec as to-dos (A3); a bare
             // when= clears an existing reminder unless auto-preserved.
             const reminder = effectiveReminder(pre, params);
@@ -1046,7 +1147,10 @@ const projectReopen = {
 };
 const projectRestore = {
     op: "project.restore",
-    hazards: ["H-UNKNOWN-DESTINATION"],
+    // H-REPEAT-SCHEDULE: a trashed repeating PROJECT template cannot be restored
+    // headlessly (Put Back only) — refuse categorically instead of the raw AS-301
+    // no-op. (The to-do path already carries it; kind-parity, 2026-08-13.)
+    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
     preRead(db, params) {
         const pre = emptyPreState();
         pre.target = loadTarget(db, params.uuid);
@@ -1390,6 +1494,13 @@ const reorder = {
         // Verify the REQUESTED sequence (strictly ascending ranks). The wire
         // list pins the unrequested tail too, but the caller's contract is the
         // requested prefix; tail members are covered by pre-rank tripwires.
+        // TODWIRE: on the `today` scope the wire is now MINIMAL — only the named
+        // block gets fresh (front, monotonic) `todayIndex`; the unnamed tail keeps
+        // its cohort-interleaved (non-monotonic) `todayIndex`, so the FULL
+        // `params.uuids` is NOT strictly-ascending after the write. Verify the
+        // `todayWire` (the named block) instead — it lands at the visible front in
+        // wire order with fresh ascending values, and the untouched tail rides the
+        // pre-rank tripwires. Every other scope verifies the requested prefix.
         // LOGSORT ORD-13 byte-lock: any admitted UNSWEPT-resolved movee must read
         // back index-only — status still closed, stoppedDate intact, umd unbumped
         // (a reopen would flip all three). Frozen assertions carry that into verify.
@@ -1400,11 +1511,14 @@ const reorder = {
                 { field: "stoppedDate", equals: m.stoppedDate },
             ],
         }));
+        const sequence = params.scope === "today" && pre.reorder?.todayWire != null
+            ? pre.reorder.todayWire
+            : params.uuids;
         return {
             mode: "ordering",
             key: pre.reorder?.key ??
                 (params.scope === "today" || params.scope === "evening" ? "todayIndex" : "index"),
-            sequence: params.uuids,
+            sequence,
             ...(frozen.length > 0 && { frozen }),
         };
     },
@@ -1429,7 +1543,14 @@ const reorder = {
                                 : params.scope === "upcoming"
                                     ? `list "Upcoming"`
                                     : `list "Today"`;
-        const wire = pre.reorder?.wireList ?? params.uuids;
+        // TODWIRE — the `today` scope sends the MINIMAL visible-order wire (names only
+        // what must move; unnamed rows keep their entry cohorts + visible positions),
+        // not the OLD full `wireList` that fused every cohort (MOVPLC/ORD-20). Every
+        // other native scope keeps the full wire (their `index`/day axes do not
+        // re-stamp `tiRef`, so a full re-rank is non-damaging).
+        const wire = (params.scope === "today" ? pre.reorder?.todayWire : undefined) ??
+            pre.reorder?.wireList ??
+            params.uuids;
         if (params.scope === "someday") {
             // The Someday handler STACKS each sent id above the list's current top
             // (the current top itself never moves), with OPPOSITE stack directions
@@ -1514,8 +1635,8 @@ function setDatesSpec(op, addressor) {
         op,
         hazards: ["H-UNKNOWN-DESTINATION", "H-BACKDATE-OPEN"],
         preRead(db, params) {
-            if (params.completionDate === undefined && params.creationDate === undefined) {
-                throw new RangeError("nothing to set: give completionDate and/or creationDate");
+            if (params.completedAt === undefined && params.createdAt === undefined) {
+                throw new RangeError("nothing to set: give completedAt and/or createdAt");
             }
             const pre = emptyPreState();
             pre.target = loadTarget(db, params.uuid);
@@ -1523,16 +1644,16 @@ function setDatesSpec(op, addressor) {
         },
         expectedDelta(_pre, params, ctx) {
             const assert = [];
-            if (params.completionDate !== undefined) {
+            if (params.completedAt !== undefined) {
                 assert.push({
                     field: "stoppedDate",
-                    equals: hostLocalDate(resolveResolutionInstant(params.completionDate, ctx.zone)),
+                    equals: hostLocalDate(resolveResolutionInstant(params.completedAt, ctx.zone)),
                 });
             }
-            if (params.creationDate !== undefined) {
+            if (params.createdAt !== undefined) {
                 assert.push({
                     field: "createdDate",
-                    equals: hostLocalDate(resolveResolutionInstant(params.creationDate, ctx.zone)),
+                    equals: hostLocalDate(resolveResolutionInstant(params.createdAt, ctx.zone)),
                 });
             }
             return { mode: "update", uuid: params.uuid, assert };
@@ -1541,11 +1662,11 @@ function setDatesSpec(op, addressor) {
             if (vector !== "applescript")
                 unsupportedVector(this.op, vector);
             const statements = [];
-            if (params.completionDate !== undefined) {
-                statements.push(...asDateBlockFromInstant("compDate", resolveResolutionInstant(params.completionDate, ctx.zone)), `set completion date of ${addressor} id ${q(params.uuid)} to compDate`);
+            if (params.completedAt !== undefined) {
+                statements.push(...asDateBlockFromInstant("compDate", resolveResolutionInstant(params.completedAt, ctx.zone)), `set completion date of ${addressor} id ${q(params.uuid)} to compDate`);
             }
-            if (params.creationDate !== undefined) {
-                statements.push(...asDateBlockFromInstant("createDate", resolveResolutionInstant(params.creationDate, ctx.zone)), `set creation date of ${addressor} id ${q(params.uuid)} to createDate`);
+            if (params.createdAt !== undefined) {
+                statements.push(...asDateBlockFromInstant("createDate", resolveResolutionInstant(params.createdAt, ctx.zone)), `set creation date of ${addressor} id ${q(params.uuid)} to createDate`);
             }
             return osaBlock(statements);
         },
@@ -2013,7 +2134,7 @@ const projectResumeRepeat = {
 };
 // project.make-repeating: the pure-AX row-selection op (UIC4). The command
 // spec drives the area / someday cases; the area-less-anytime coercion is done
-// by the runMakeRepeatingProject orchestrator BEFORE this spec sees the target,
+// by the promoteProjectViaGui internal orchestrator BEFORE this spec sees the target,
 // so by drive time the taxonomy is always area or someday. A DIRECT dispatch on
 // an anytime project is refused by H-PROJECT-REPEAT (with the orchestrator as
 // the remediation).
@@ -2091,6 +2212,25 @@ const projectAddRepeating = {
         throw new Error(ADD_REPEATING_ORCHESTRATED);
     },
 };
+// todo.add-repeating is delivered by the runAddRepeatingTodo orchestrator
+// (todo.add THEN native promote); it has no atomic surface and is never
+// dispatched directly through the pipeline (promote-clone.ts).
+const TODO_ADD_REPEATING_ORCHESTRATED = "todo.add-repeating is delivered by the runAddRepeatingTodo orchestrator (create the to-do, " +
+    "then promote it to a repeating series); it has no atomic surface and is never dispatched " +
+    "directly through the pipeline";
+const todoAddRepeating = {
+    op: "todo.add-repeating",
+    hazards: [],
+    preRead() {
+        return emptyPreState();
+    },
+    expectedDelta() {
+        throw new Error(TODO_ADD_REPEATING_ORCHESTRATED);
+    },
+    compile() {
+        throw new Error(TODO_ADD_REPEATING_ORCHESTRATED);
+    },
+};
 const todoConvertToProject = {
     op: "todo.convert-to-project",
     hazards: UI_HAZARDS,
@@ -2356,6 +2496,29 @@ const trashEmpty = {
         return osa("empty trash");
     },
 };
+const logNow = {
+    op: "log-now",
+    hazards: [],
+    preRead(db, _params, now, zone) {
+        const pre = emptyPreState();
+        // The resolved-but-unlogged census the verb will move (the disclosed count),
+        // and the pre-op boundary stamp the delta compares against.
+        pre.logNow = {
+            pending: pendingLogCount(db, now, zone),
+            manualLogDatePre: manualLogDateEpoch(db),
+        };
+        return pre;
+    },
+    expectedDelta(pre) {
+        const ln = pre.logNow ?? { pending: 0, manualLogDatePre: null };
+        return { mode: "logged-now", pending: ln.pending, manualLogDatePre: ln.manualLogDatePre };
+    },
+    compile(_params, vector) {
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        return osa("log completed now");
+    },
+};
 export const COMMANDS = {
     "todo.add": todoAdd,
     "todo.update": todoUpdate,
@@ -2409,5 +2572,9 @@ export const COMMANDS = {
     "area.reorder": areaReorderSidebar,
     "project.make-repeating": projectMakeRepeating,
     "project.add-repeating": projectAddRepeating,
+    "todo.add-repeating": todoAddRepeating,
+    "todo.clone": todoClone,
+    "project.clone": projectClone,
+    "log-now": logNow,
 };
 //# sourceMappingURL=commands.js.map