things-api 0.17.0 → 0.19.0

package/dist/write/commands.js

@@ -1,16 +1,16 @@
-import { decodeReminderTime, encodeReminderTime, localToday, reminderUrlToken, zonedWallInstant, } from "../model/dates.js";
+import { localToday, 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";
+import { areaMemberCounts, childTagTitles, classifyHeadingConvert, classifyHeadingDissolve, classifyHeadingMoveToProject, classifyProjectRepeat, computeHeadingMovePre, computeReorderPre, emptyPreState, loadTarget, projectChildren, projectStatus, projectSubtreeUuids, resolveArea, resolveHeading, resolveProject, resolveTag, sameTitleTaskUuids, seriesRowUuids, trashedCount, } from "./pre-state.js";
+import { assertNotesModesExclusive, normalizeReminder, updateAssertions, updateWireParams, whenAssertions, whenWithReminder, } from "./update-fields.js";
 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 { assessOffRuleFirst, deadlineDriveNext, deriveFixedAnchor } 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 { areaReorderSidebarRecipe, convertToProjectRecipe, dissolveHeadingRecipe, headingConvertToProjectRecipe, moveHeadingToProjectRecipe, makeRepeatingRecipe, createNextCopyRecipe, pauseRepeatRecipe, projectMakeRepeatingRecipe, projectPauseRepeatRecipe, projectRescheduleRepeatRecipe, projectResumeRepeatRecipe, rescheduleRepeatRecipe, resumeRepeatRecipe, } from "./vectors/ui-recipes.js";
 import { buildRepeatingFingerprint } from "./verify/delta.js";
 // ------------------------------------------------------------------ helpers
 function thingsUrl(command, params, token) {
@@ -65,65 +65,6 @@ function q(value) {
 function unsupportedVector(op, vector) {
     throw new Error(`${op} cannot be compiled for vector ${vector} (planner bug)`);
 }
-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,
-    // reporting a false mismatch on a write that succeeded.
-    if (when !== "today" &&
-        when !== "evening" &&
-        when !== "anytime" &&
-        when !== "someday" &&
-        !/^\d{4}-\d{2}-\d{2}$/.test(when)) {
-        throw new RangeError(when.includes("@")
-            ? `invalid when "${when}" — a reminder time is a separate parameter (reminder: "HH:mm"; CLI --reminder), not an @ suffix`
-            : `invalid when "${when}" — expected today | evening | anytime | someday | YYYY-MM-DD`);
-    }
-    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" },
-                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: "evening", equals: true },
-            ];
-        case "anytime":
-            return [
-                { field: "start", equals: "active" },
-                { field: "startDate", equals: null },
-            ];
-        case "someday":
-            return [{ field: "start", equals: "someday" }];
-        default:
-            // Concrete date: assert only the date — start-state semantics differ
-            // for past/today/future dates (only the date itself is invariant).
-            return [{ field: "startDate", equals: when }];
-    }
-}
 function sortedTags(tags) {
     return [...tags].toSorted();
 }
@@ -139,21 +80,28 @@ function applyTagRefs(db, pre, tags) {
     pre.missingTags = res.missing;
     pre.resolvedTagTitles = res.titles;
 }
-/** Round-trip normalization: "6:5"-style inputs → canonical "06:05". */
-function normalizeReminder(time) {
-    return decodeReminderTime(encodeReminderTime(time)) ?? time;
-}
 /**
- * The URL `when` value with an optional reminder token appended through the
- * deterministic emitter (never a bare 1–11 hour — oddity 2d).
+ * Is a destination container SUPPLIED? A PRESENCE check, not a duck-test (#580):
+ * the parameter schema (param-schema.ts) has already proven that a present ref is
+ * a `{uuid}`/`{title}` object, so anything else reaching here is an engine bug,
+ * not caller input — and it THROWS rather than reading as "no destination given",
+ * which is precisely how a bare-string `project` used to compile an Inbox capture
+ * with no placement and no placement assertion, then verify clean.
  */
-function whenWithReminder(when, reminder) {
-    if (reminder === undefined || reminder === null)
-        return when;
-    return `${when}@${reminderUrlToken(reminder)}`;
+export function containerGiven(ref) {
+    if (ref === undefined || ref === null)
+        return false;
+    assertContainerRef(ref);
+    return true;
 }
-function containerGiven(ref) {
-    return ref !== undefined && (ref.uuid !== undefined || ref.title !== undefined);
+/** Belt-and-braces: a present container reference must carry a uuid or a title. */
+export function assertContainerRef(ref) {
+    if (typeof ref !== "object" || Array.isArray(ref)) {
+        throw new RangeError(`a container reference must be an object naming a uuid or a title — received ${JSON.stringify(ref)}`);
+    }
+    if (ref.uuid === undefined && ref.title === undefined) {
+        throw new RangeError("a container reference must name a uuid or a title — it names neither");
+    }
 }
 /**
  * The create-probe title for the duplicate / identity-replacement ops, whose
@@ -351,108 +299,35 @@ const todoAdd = {
     },
 };
 /**
- * The effective reminder a when-bearing update should leave behind. A bare
- * `when=` CLEARS an existing reminder (R07/R20), so when the caller
- * re-schedules to today/evening/a date without addressing the reminder we
- * auto-preserve the current one; an explicit null is the intentional clear.
- *
- * §9n: a reminder whose row's `startDate` is already strictly PAST is
- * presentation-dead (the GUI hides its bell; the byte lingers in the DB). We do
- * NOT auto-preserve such a stale byte — carrying it into the re-schedule would
- * RESURRECT a reminder the user believes gone. A LIVE reminder (startDate
- * today/future) is preserved as before. The liveness test is the SAME
- * {@link reminderIsLive} predicate the read side gates on, consulted against the
- * target's CURRENT `startDate` under the response clock.
+ * The to-do / project update pair. Both legs — the URL parameters and the
+ * expected-delta assertions — are DERIVED from the single exhaustive registry in
+ * update-fields.ts (the #491 exhaustive-map doctrine): the only per-verb
+ * difference is the URL command name, so neither verb can accept a field the
+ * other drops, and a field added to `UpdateFields` breaks compilation there
+ * until every leg handles it.
  */
-function effectiveReminder(pre, params) {
-    if (params.reminder !== undefined)
-        return params.reminder;
-    const when = params.when;
-    const schedulable = when === "today" ||
-        when === "evening" ||
-        (typeof when === "string" && /^\d{4}-\d{2}-\d{2}$/.test(when));
-    if (!schedulable)
-        return null;
-    const target = pre.target;
-    if (target === null || target.type === "heading")
-        return null;
-    if (!reminderIsLive(target.startDate, pre.todayIso))
-        return null;
-    // 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 &&
-        (params.appendNotes !== undefined || params.prependNotes !== undefined)) {
-        throw new RangeError("notes (replace) is exclusive with appendNotes/prependNotes");
-    }
-    if (params.appendNotes !== undefined && params.prependNotes !== undefined) {
-        throw new RangeError("appendNotes and prependNotes cannot be combined in one update");
-    }
-}
-function expectedNotes(pre, params) {
-    const current = pre.target !== null && pre.target.type !== "heading" ? pre.target.notes : "";
-    // Separator semantics probed: newline-joined, no stray newline against an
-    // empty note (E04/E05/E11/E12).
-    if (params.appendNotes !== undefined) {
-        return current === "" ? params.appendNotes : `${current}\n${params.appendNotes}`;
-    }
-    if (params.prependNotes !== undefined) {
-        return current === "" ? params.prependNotes : `${params.prependNotes}\n${current}`;
-    }
-    return undefined;
+function updateSpec(op, urlCommand) {
+    return {
+        op,
+        hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE", "H-REMINDER-SCOPE"],
+        preRead(db, params, now) {
+            assertNotesModesExclusive(params);
+            const pre = emptyPreState();
+            pre.todayIso = localToday(now);
+            pre.target = loadTarget(db, params.uuid);
+            return pre;
+        },
+        expectedDelta(pre, params, ctx) {
+            return { mode: "update", uuid: params.uuid, assert: updateAssertions(params, pre, ctx) };
+        },
+        compile(params, vector, pre, ctx) {
+            if (vector !== "url-scheme")
+                unsupportedVector(op, vector);
+            return thingsUrl(urlCommand, { id: params.uuid, ...updateWireParams(params, pre) }, ctx.token);
+        },
+    };
 }
-const todoUpdate = {
-    op: "todo.update",
-    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE", "H-REMINDER-SCOPE"],
-    preRead(db, params, now) {
-        assertNotesModesExclusive(params);
-        const pre = emptyPreState();
-        pre.todayIso = localToday(now);
-        pre.target = loadTarget(db, params.uuid);
-        return pre;
-    },
-    expectedDelta(pre, params, ctx) {
-        const assert = [];
-        if (params.title !== undefined)
-            assert.push({ field: "title", equals: params.title });
-        if (params.notes !== undefined)
-            assert.push({ field: "notes", equals: params.notes });
-        const joined = expectedNotes(pre, params);
-        if (joined !== undefined)
-            assert.push({ field: "notes", equals: joined });
-        if (params.when !== undefined) {
-            assert.push(...whenAssertions(params.when, ctx.todayIso, { mode: "update" }));
-            const reminder = effectiveReminder(pre, params);
-            assert.push({
-                field: "reminder",
-                equals: reminder === null ? null : normalizeReminder(reminder),
-            });
-        }
-        if (params.deadline !== undefined)
-            assert.push({ field: "deadline", equals: params.deadline });
-        return { mode: "update", uuid: params.uuid, assert };
-    },
-    compile(params, vector, pre, ctx) {
-        if (vector !== "url-scheme")
-            unsupportedVector(this.op, vector);
-        return thingsUrl("update", {
-            id: params.uuid,
-            title: params.title,
-            notes: params.notes,
-            "append-notes": params.appendNotes,
-            "prepend-notes": params.prependNotes,
-            when: params.when === undefined
-                ? undefined
-                : whenWithReminder(params.when, effectiveReminder(pre, params)),
-            deadline: params.deadline === null ? "" : params.deadline,
-        }, ctx.token);
-    },
-};
+const todoUpdate = updateSpec("todo.update", "update");
 function statusSpec(op, urlParam, asStatus, scriptStatus) {
     return {
         op,
@@ -826,6 +701,14 @@ const projectAdd = {
         const area = pre.destArea?.resolved;
         if (area !== undefined && area !== null)
             assert.push({ field: "area.uuid", equals: area.uuid });
+        // KNOWN SHALLOW SPOT (audited 2026-08-23, exhaustive-map sweep): the seeded
+        // children — `todos` and the structured `items` (headings + rich children) —
+        // contribute NO assertion, so a project born with an empty body still
+        // verifies `ok`. Unlike a to-do's `checklistItems` (asserted through
+        // `checklistTitles`) there is no child-list field on the delta vocabulary to
+        // compare against, and adding one needs probe evidence that the imported
+        // children are readable inside the verify window before a missing child may
+        // be called a failure. Tracked in docs/up-next.md; do NOT "fix" it blind.
         return {
             mode: "create",
             probe: {
@@ -873,55 +756,9 @@ const projectAdd = {
         }, ctx.token);
     },
 };
-const projectUpdate = {
-    op: "project.update",
-    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE", "H-REMINDER-SCOPE"],
-    preRead(db, params, now) {
-        assertNotesModesExclusive(params);
-        const pre = emptyPreState();
-        pre.todayIso = localToday(now);
-        pre.target = loadTarget(db, params.uuid);
-        return pre;
-    },
-    expectedDelta(pre, params, ctx) {
-        const assert = [];
-        if (params.title !== undefined)
-            assert.push({ field: "title", equals: params.title });
-        if (params.notes !== undefined)
-            assert.push({ field: "notes", equals: params.notes });
-        const joined = expectedNotes(pre, params);
-        if (joined !== undefined)
-            assert.push({ field: "notes", equals: joined });
-        if (params.when !== undefined) {
-            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);
-            assert.push({
-                field: "reminder",
-                equals: reminder === null ? null : normalizeReminder(reminder),
-            });
-        }
-        if (params.deadline !== undefined)
-            assert.push({ field: "deadline", equals: params.deadline });
-        return { mode: "update", uuid: params.uuid, assert };
-    },
-    compile(params, vector, pre, ctx) {
-        if (vector !== "url-scheme")
-            unsupportedVector(this.op, vector);
-        return thingsUrl("update-project", {
-            id: params.uuid,
-            title: params.title,
-            notes: params.notes,
-            "append-notes": params.appendNotes,
-            "prepend-notes": params.prependNotes,
-            when: params.when === undefined
-                ? undefined
-                : whenWithReminder(params.when, effectiveReminder(pre, params)),
-            deadline: params.deadline === null ? "" : params.deadline,
-        }, ctx.token);
-    },
-};
+// Projects carry the same reminderTime codec and notes/schedule semantics as
+// to-dos (A3/E18) — same registry, same legs, only the URL command differs.
+const projectUpdate = updateSpec("project.update", "update-project");
 const projectSetTags = {
     op: "project.set-tags",
     hazards: ["H-UNKNOWN-DESTINATION", "H-UNKNOWN-TAG"],
@@ -1921,16 +1758,39 @@ function ruleExtras(params) {
     };
 }
 /**
- * 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.
+ * The reschedule's EFFECTIVE rule params: the requested params PLUS the calendar
+ * anchor DERIVED from `--when` when none was given explicitly (YANCH1 #493 — the
+ * SAME derive-and-drive make/add-repeating apply upstream in promote-clone.ts).
+ * The anchor is derived from the deadline-shifted drive date (`deadlineDriveNext`
+ * = when + startDaysEarlier) so a deadlined rule's anchor names the DUE date,
+ * exactly as make/add. A rule-only reschedule (no `--when`) or an explicit anchor
+ * flag leaves params UNCHANGED (deriveFixedAnchor returns an empty patch).
+ *
+ * This is the single source of truth used by BOTH the compile (`reschedRuleExtras`
+ * → the recipe DRIVES the anchor pop-ups) AND expectedDelta (`expectedRuleAssertions`
+ * ASSERTS the same anchor), so the drive vocabulary and the verify vocabulary
+ * derive IDENTICALLY. Without it a `--when`-only reschedule left the anchor at the
+ * dialog's untouched default (yearly January 1, monthly 1st, weekly Sunday) — the
+ * DRIVE never touched the anchor pop-ups while the reschedule silently kept the old
+ * placement (the RSPA1 live failure: a yearly `--when`-only reschedule whose anchor
+ * was never driven).
+ */
+function reschedEffParams(params) {
+    return { ...params, ...deriveFixedAnchor(params, deadlineDriveNext(params)) };
+}
+/**
+ * Recipe extras for a RESCHEDULE: the derived-anchor effective params (so the
+ * recipe drives the weekly/monthly/yearly anchor pop-ups for a `--when`-only
+ * 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 base = ruleExtras(reschedEffParams(params));
     const drive = deadlineDriveNext(params);
     return drive !== undefined ? { ...base, next: drive } : base;
 }
@@ -2002,11 +1862,22 @@ const todoRescheduleRepeat = {
         // 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.
+        // so the undo can re-drive it faithfully. The DERIVED-anchor effective params
+        // (reschedEffParams) are asserted — the SAME bag the compile drives — so a
+        // `--when`-only reschedule verifies the derived anchor the drive lands (RSPA1).
+        const eff = reschedEffParams(params);
         return {
             mode: "update",
             uuid: params.uuid,
-            assert: expectedRuleAssertions(params, { includeCursor: true }),
+            // includeCursor asserts the first-occurrence cursor == --when. For an OFF-RULE
+            // first (explicit anchor ≠ --when) the cursor lands on the next RULE-ALIGNED
+            // occurrence, not --when (DACON1 cell DC4: --when Oct 16 with an Oct-16 due
+            // anchor cursors to the next aligned start, 2029-10-02), so asserting it would
+            // false-fail an honored off-rule reschedule — drop the cursor assertion there
+            // and verify the rule anchor only.
+            assert: expectedRuleAssertions(eff, {
+                includeCursor: assessOffRuleFirst(eff)?.kind !== "honored",
+            }),
             capture: [{ field: "repeating.rule" }, { field: "repeating.deadlined" }],
         };
     },
@@ -2038,6 +1909,56 @@ const todoPauseRepeat = {
         return uiDrive(pauseRepeatRecipe(params.uuid));
     },
 };
+/**
+ * `Items ▸ Repeat ▸ Create Next Copy` (CNC1) — materialize the pending
+ * occurrence and advance the series. The INTERNAL first leg of the
+ * template-mutation composites (template-mutation.ts); it is not a user-facing
+ * verb, because a bare "spawn one now" has no use we have been asked for and
+ * every honest use of it mutates the row it mints.
+ *
+ * Verified as a CREATE: the minted row wears the template's own title, is a
+ * to-do, carries a fresh (gesture wall-clock) creationDate, and is not one of
+ * the rows the series already had — which is exactly the create-probe's
+ * gauntlet, and it hands the composite back the minted uuid it needs. The one
+ * field assertion is the FK: the discovered row must be an instance of THIS
+ * template, so a same-titled row created by anything else in the window cannot
+ * pass. The cursor advance is deliberately NOT asserted here — a create delta
+ * asserts against the created row, and the composite re-reads the template
+ * afterwards anyway to disclose when the next occurrence lands.
+ */
+const todoCreateNextCopy = {
+    op: "todo.create-next-copy",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        // The series' existing rows — the template plus every instance it has
+        // already spawned, all of which share its title. They are the create
+        // probe's exclusion set, so "the new row" is unambiguous even on a series
+        // whose occurrences all look alike.
+        pre.sameTitleUuids = seriesRowUuids(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(pre, params, ctx) {
+        const target = pre.target;
+        const title = target !== null && target.type !== "heading" ? target.title : "";
+        return {
+            mode: "create",
+            probe: {
+                title,
+                type: "to-do",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+            },
+            assert: [{ field: "repeating.templateUuid", equals: params.uuid }],
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        return uiDrive(createNextCopyRecipe(params.uuid));
+    },
+};
 const todoResumeRepeat = {
     op: "todo.resume-repeat",
     hazards: UI_HAZARDS,
@@ -2080,11 +2001,22 @@ const projectRescheduleRepeat = {
         // capture the prior rule (+ deadline flag) for the faithful undo. Assert the
         // 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).
+        // anchor/deadline/ends-only reschedule). The DERIVED-anchor effective params
+        // (reschedEffParams) are asserted — the SAME bag the compile drives — so a
+        // `--when`-only reschedule verifies the derived anchor the drive lands (RSPA1).
+        const eff = reschedEffParams(params);
         return {
             mode: "update",
             uuid: params.uuid,
-            assert: expectedRuleAssertions(params, { includeCursor: true }),
+            // includeCursor asserts the first-occurrence cursor == --when. For an OFF-RULE
+            // first (explicit anchor ≠ --when) the cursor lands on the next RULE-ALIGNED
+            // occurrence, not --when (DACON1 cell DC4: --when Oct 16 with an Oct-16 due
+            // anchor cursors to the next aligned start, 2029-10-02), so asserting it would
+            // false-fail an honored off-rule reschedule — drop the cursor assertion there
+            // and verify the rule anchor only.
+            assert: expectedRuleAssertions(eff, {
+                includeCursor: assessOffRuleFirst(eff)?.kind !== "honored",
+            }),
             capture: [{ field: "repeating.rule" }, { field: "repeating.deadlined" }],
         };
     },
@@ -2567,6 +2499,7 @@ export const COMMANDS = {
     "todo.make-repeating": todoMakeRepeating,
     "todo.reschedule-repeat": todoRescheduleRepeat,
     "todo.pause-repeat": todoPauseRepeat,
+    "todo.create-next-copy": todoCreateNextCopy,
     "todo.resume-repeat": todoResumeRepeat,
     "todo.convert-to-project": todoConvertToProject,
     "project.reschedule-repeat": projectRescheduleRepeat,