things-api 0.15.0 → 0.17.0

package/dist/write/commands.js

@@ -7,6 +7,8 @@ import { areaMemberCounts, childTagTitles, classifyHeadingConvert, classifyHeadi
 import { resolveTagRefs } from "./tag-refs.js";
 import { PRIVATE_REORDER_COMMAND } from "./experimental.js";
 import { assertRepeatRule } from "./repeat-rule.js";
+import { deadlineDriveNext } from "./repeat-anchor.js";
+import { expectedRuleAssertions } from "./repeat-asserts.js";
 import { escapeAppleScript } from "./vectors/applescript.js";
 import { areaReorderSidebarRecipe, convertToProjectRecipe, dissolveHeadingRecipe, headingConvertToProjectRecipe, moveHeadingToProjectRecipe, makeRepeatingRecipe, pauseRepeatRecipe, projectMakeRepeatingRecipe, projectPauseRepeatRecipe, projectRescheduleRepeatRecipe, projectResumeRepeatRecipe, rescheduleRepeatRecipe, resumeRepeatRecipe, } from "./vectors/ui-recipes.js";
 import { buildRepeatingFingerprint } from "./verify/delta.js";
@@ -455,9 +457,12 @@ function statusSpec(op, urlParam, asStatus, scriptStatus) {
     return {
         op,
         hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
-        preRead(db, params) {
+        preRead(db, params, now, zone) {
             const pre = emptyPreState();
-            pre.target = loadTarget(db, params.uuid);
+            // Load under the response clock so the target's Today marker (read by the
+            // HINTS1 completion-context) reflects the same calendar day the pipeline
+            // verifies under, not the host wall clock.
+            pre.target = loadTarget(db, params.uuid, now, zone);
             return pre;
         },
         expectedDelta(_pre, params) {
@@ -644,6 +649,33 @@ function checklistItemsJsonAttr(specs) {
         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 }
@@ -715,6 +747,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"],
@@ -744,6 +798,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);
@@ -779,7 +840,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;
@@ -789,7 +852,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 } }));
                 }
             }
@@ -1086,7 +1152,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);
@@ -1848,8 +1917,23 @@ function ruleExtras(params) {
         ...(params.reminder !== undefined && { reminder: params.reminder }),
         ...(params.deadline !== undefined && { deadline: params.deadline }),
         ...(params.startDaysEarlier !== undefined && { startDaysEarlier: params.startDaysEarlier }),
+        ...(params.next !== undefined && { next: params.next }),
     };
 }
+/**
+ * Recipe extras for a RESCHEDULE, with the "Next:" drive date deadline-adjusted
+ * (YANCH1 #493): `--when` is the scheduled START, but a deadlined rule anchors on
+ * the DEADLINE, so the dialog's "Next:" field is driven with `when +
+ * startDaysEarlier` and the app back-shifts the instance start to `--when`. The
+ * expectedDelta keeps the RAW `params.next` (the cursor asserts the START).
+ * make/add-repeating apply this shift upstream (promote-clone.ts) and pass an
+ * already-adjusted rule, so only the reschedule compile needs it here.
+ */
+function reschedRuleExtras(params) {
+    const base = ruleExtras(params);
+    const drive = deadlineDriveNext(params);
+    return drive !== undefined ? { ...base, next: drive } : base;
+}
 /** ui ops all guard existence/type + the H-UI-DRIVE acknowledgement. */
 const UI_HAZARDS = ["H-UNKNOWN-DESTINATION", "H-UI-DRIVE"];
 const todoMakeRepeating = {
@@ -1870,9 +1954,12 @@ const todoMakeRepeating = {
         // rows), pick it by asserting it IS a template, then the `repeating` context
         // hardens discovery (restored time-bound, source-fingerprint tiebreak) and
         // derives instance + source fate for the enriched result. `expectedRule`
-        // makes the LANDED rule verifiable: a template minted with the wrong
-        // frequency/interval (the interval-field race, oddities §8l) becomes a
-        // verify-failed:mismatch instead of a silent ok.
+        // makes the LANDED rule verifiable at FULL fidelity (#491): a template minted
+        // with the wrong frequency/interval (the interval-field race, oddities §8l) OR
+        // a dropped anchor / ends / deadline becomes a verify-failed:mismatch instead
+        // of a silent ok. includeCursor:false — the fresh template's cursor follows
+        // the app's spawn law (ANCH1), not the raw --when, so make verifies the rule
+        // BLOB + deadline, not the cursor.
         return {
             mode: "create",
             probe: {
@@ -1884,11 +1971,7 @@ const todoMakeRepeating = {
                     repeating: {
                         sourceUuid: pre.target.uuid,
                         fingerprint: buildRepeatingFingerprint(pre.target),
-                        expectedRule: {
-                            type: params.afterCompletion === true ? "after-completion" : "fixed",
-                            unit: params.frequency,
-                            interval: params.interval,
-                        },
+                        expectedRule: expectedRuleAssertions(params, { includeCursor: false }),
                     },
                 }),
             },
@@ -1911,33 +1994,26 @@ const todoRescheduleRepeat = {
         return pre;
     },
     expectedDelta(_pre, params) {
-        // Identity PRESERVED (UI2-b): the same template uuid, rule mutated in
-        // place. Assert the decoded rule's TYPE + frequency + interval; ALSO capture
-        // the whole prior rule (+ deadline flag) so the undo can re-drive it
-        // faithfully. Asserting `type` (fixed vs after-completion) is what makes a
-        // fixed→after-completion conversion VERIFIABLE at all: in the field-report
-        // incident (0½ item 1) both rules were weekly/interval-2, so unit+interval
-        // never changed — only the type flipped, and without this assertion verify
-        // could neither confirm the conversion landed nor tell the pre-drive
-        // idempotency check that the target had not yet been reached.
+        // Identity PRESERVED (UI2-b): the same template uuid, rule mutated in place.
+        // Assert the FULL requested rule (#491) — type + unit + interval + calendar
+        // anchor + ends bound + deadline offset + the ANCH2 first-occurrence cursor —
+        // built from the complete vocabulary by expectedRuleAssertions so the pre-drive
+        // idempotency check skips ONLY when EVERY requested field already holds, and
+        // the post-drive verify catches a wrong-anchor landing. A shallow unit+interval
+        // subset false-noop'd a reschedule that changed only the monthly anchor /
+        // deadline / ends (#491). ALSO capture the whole prior rule (+ deadline flag)
+        // so the undo can re-drive it faithfully.
         return {
             mode: "update",
             uuid: params.uuid,
-            assert: [
-                {
-                    field: "repeating.rule.type",
-                    equals: params.afterCompletion === true ? "after-completion" : "fixed",
-                },
-                { field: "repeating.rule.unit", equals: params.frequency },
-                { field: "repeating.rule.interval", equals: params.interval },
-            ],
+            assert: expectedRuleAssertions(params, { includeCursor: true }),
             capture: [{ field: "repeating.rule" }, { field: "repeating.deadlined" }],
         };
     },
     compile(params, vector) {
         if (vector !== "ui")
             unsupportedVector(this.op, vector);
-        return uiDrive(rescheduleRepeatRecipe(params.uuid, params.frequency, params.interval, ruleExtras(params)));
+        return uiDrive(rescheduleRepeatRecipe(params.uuid, params.frequency, params.interval, reschedRuleExtras(params)));
     },
 };
 const todoPauseRepeat = {
@@ -2002,26 +2078,20 @@ const projectRescheduleRepeat = {
     expectedDelta(_pre, params) {
         // Identity PRESERVED (UIC2-a): same project uuid, rule mutated in place;
         // capture the prior rule (+ deadline flag) for the faithful undo. Assert the
-        // rule TYPE too (fixed vs after-completion) so a conversion that leaves
-        // unit+interval unchanged is still verifiable — see todo.reschedule-repeat.
+        // FULL requested rule (#491) via expectedRuleAssertions — same completeness as
+        // todo.reschedule-repeat (a shallow unit+interval subset false-noop'd an
+        // anchor/deadline/ends-only reschedule).
         return {
             mode: "update",
             uuid: params.uuid,
-            assert: [
-                {
-                    field: "repeating.rule.type",
-                    equals: params.afterCompletion === true ? "after-completion" : "fixed",
-                },
-                { field: "repeating.rule.unit", equals: params.frequency },
-                { field: "repeating.rule.interval", equals: params.interval },
-            ],
+            assert: expectedRuleAssertions(params, { includeCursor: true }),
             capture: [{ field: "repeating.rule" }, { field: "repeating.deadlined" }],
         };
     },
     compile(params, vector) {
         if (vector !== "ui")
             unsupportedVector(this.op, vector);
-        return uiDrive(projectRescheduleRepeatRecipe(params.uuid, params.frequency, params.interval, ruleExtras(params)));
+        return uiDrive(projectRescheduleRepeatRecipe(params.uuid, params.frequency, params.interval, reschedRuleExtras(params)));
     },
 };
 const projectPauseRepeat = {
@@ -2070,7 +2140,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).
@@ -2094,7 +2164,10 @@ const projectMakeRepeating = {
         // the current-occurrence instance. Pick the TEMPLATE by asserting it IS one,
         // excluding pre-existing same-title rows; the `repeating` context hardens
         // discovery and derives instance + source fate + childrenReplaced.
-        // `expectedRule` makes the landed rule verifiable (interval-race guard, §8l).
+        // `expectedRule` makes the landed rule verifiable at FULL fidelity (#491):
+        // a wrong frequency/interval (interval-race §8l) OR a dropped anchor/ends/
+        // deadline is a mismatch, not a silent ok. includeCursor:false — the fresh
+        // template's cursor follows the ANCH1 spawn law, not the raw --when.
         return {
             mode: "create",
             probe: {
@@ -2107,11 +2180,7 @@ const projectMakeRepeating = {
                         sourceUuid: pre.target.uuid,
                         fingerprint: buildRepeatingFingerprint(pre.target),
                         subtreeUuids: pre.repeatSubtreeUuids ?? [],
-                        expectedRule: {
-                            type: params.afterCompletion === true ? "after-completion" : "fixed",
-                            unit: params.frequency,
-                            interval: params.interval,
-                        },
+                        expectedRule: expectedRuleAssertions(params, { includeCursor: false }),
                     },
                 }),
             },
@@ -2148,6 +2217,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,
@@ -2489,6 +2577,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