things-api 0.9.0 → 0.11.0

package/dist/write/commands.js

@@ -1,8 +1,12 @@
 import { decodeReminderTime, encodeReminderTime, reminderUrlToken, } from "../model/dates.js";
 import { byUuid } from "../read/detail.js";
-import { childTagTitles, computeReorderPre, emptyPreState, loadTarget, missingTagTitles, projectChildren, projectStatus, resolveArea, resolveHeading, resolveProject, resolveTag, trashedCount, } from "./pre-state.js";
+import { childTagTitles, classifyHeadingConvert, classifyProjectRepeat, computeReorderPre, emptyPreState, loadTarget, projectChildren, projectStatus, projectSubtreeUuids, resolveArea, resolveHeading, resolveProject, resolveTag, sameTitleTaskUuids, trashedCount, } from "./pre-state.js";
+import { resolveTagRefs } from "./tag-refs.js";
 import { PRIVATE_REORDER_COMMAND } from "./experimental.js";
+import { assertRepeatRule } from "./repeat-rule.js";
 import { escapeAppleScript } from "./vectors/applescript.js";
+import { areaReorderSidebarRecipe, convertToProjectRecipe, headingConvertToProjectRecipe, makeRepeatingRecipe, pauseRepeatRecipe, projectMakeRepeatingRecipe, projectPauseRepeatRecipe, projectRescheduleRepeatRecipe, projectResumeRepeatRecipe, rescheduleRepeatRecipe, resumeRepeatRecipe, } from "./vectors/ui-recipes.js";
+import { buildRepeatingFingerprint } from "./verify/delta.js";
 // ------------------------------------------------------------------ helpers
 function thingsUrl(command, params, token) {
     const parts = [];
@@ -99,6 +103,18 @@ function whenAssertions(when, todayIso) {
 function sortedTags(tags) {
     return [...tags].toSorted();
 }
+/**
+ * Resolve tag refs (title or `parent/child` path — names only) into pre-state:
+ * the leaf titles to apply, plus the unknown (`missingTags`) refs the
+ * H-UNKNOWN-TAG guard refuses on. Tags apply BY NAME through the app's own
+ * vector, so the app resolves the name (duplicate names resolve app-side, as
+ * in the GUI) — the resolver is a pure existence check.
+ */
+function applyTagRefs(db, pre, tags) {
+    const res = resolveTagRefs(db, 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;
@@ -115,6 +131,17 @@ function whenWithReminder(when, reminder) {
 function containerGiven(ref) {
     return ref !== undefined && (ref.uuid !== undefined || ref.title !== undefined);
 }
+/**
+ * The create-probe title for the duplicate / identity-replacement ops, whose
+ * new row inherits the pre-read target's title. Non-heading targets only (the
+ * heading-convert op uses the raw title, headings included); "" when the target
+ * did not resolve. Shared by the pre-read same-title capture and the delta so
+ * the excluded set and the probe title cannot drift apart.
+ */
+function nonHeadingTitle(pre) {
+    const target = pre.target;
+    return target !== null && target.type !== "heading" ? target.title : "";
+}
 // ----------------------------------------------------------------- commands
 const todoAdd = {
     op: "todo.add",
@@ -126,6 +153,12 @@ const todoAdd = {
         "H-REMINDER-SCOPE",
     ],
     preRead(db, params) {
+        if (containerGiven(params.project) && containerGiven(params.area)) {
+            throw new RangeError("project and area are exclusive destinations");
+        }
+        if (params.heading !== undefined && !containerGiven(params.project)) {
+            throw new RangeError("heading requires a project destination");
+        }
         const pre = emptyPreState();
         if (containerGiven(params.project)) {
             pre.destProject = resolveProject(db, params.project);
@@ -139,7 +172,8 @@ const todoAdd = {
         if (containerGiven(params.area))
             pre.destArea = resolveArea(db, params.area);
         if (params.tags !== undefined)
-            pre.missingTags = missingTagTitles(db, params.tags);
+            applyTagRefs(db, pre, params.tags);
+        pre.sameTitleUuids = sameTitleTaskUuids(db, params.title, "to-do");
         return pre;
     },
     expectedDelta(pre, params, ctx) {
@@ -153,8 +187,9 @@ const todoAdd = {
         }
         if (params.deadline !== undefined)
             assert.push({ field: "deadline", equals: params.deadline });
-        if (params.tags !== undefined)
-            assert.push({ field: "tags", equals: sortedTags(params.tags) });
+        if (params.tags !== undefined) {
+            assert.push({ field: "tags", equals: sortedTags(pre.resolvedTagTitles) });
+        }
         if (params.checklistItems !== undefined) {
             assert.push({ field: "checklistTitles", equals: params.checklistItems });
         }
@@ -171,7 +206,12 @@ const todoAdd = {
             assert.push({ field: "area.uuid", equals: area.uuid });
         return {
             mode: "create",
-            probe: { title: params.title, type: "to-do", sinceEpoch: ctx.nowEpoch - 2 },
+            probe: {
+                title: params.title,
+                type: "to-do",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+            },
             assert,
         };
     },
@@ -184,7 +224,7 @@ const todoAdd = {
             notes: params.notes,
             when: params.when === undefined ? undefined : whenWithReminder(params.when, params.reminder),
             deadline: params.deadline,
-            tags: params.tags?.join(","),
+            tags: params.tags === undefined ? undefined : pre.resolvedTagTitles.join(","),
             "checklist-items": params.checklistItems?.join("\n"),
             "list-id": container?.uuid,
             heading: pre.destHeading?.resolved?.title,
@@ -317,6 +357,12 @@ const todoMove = {
         if (params.detach === true && container) {
             throw new RangeError("detach is exclusive with project/area/heading destinations");
         }
+        if (containerGiven(params.project) && containerGiven(params.area)) {
+            throw new RangeError("project and area are exclusive destinations");
+        }
+        if (params.heading !== undefined && !containerGiven(params.project)) {
+            throw new RangeError("heading requires a project destination");
+        }
         const pre = emptyPreState();
         pre.target = loadTarget(db, params.uuid);
         if (containerGiven(params.project)) {
@@ -400,21 +446,22 @@ const todoSetTags = {
     preRead(db, params) {
         const pre = emptyPreState();
         pre.target = loadTarget(db, params.uuid);
-        pre.missingTags = missingTagTitles(db, params.tags);
+        applyTagRefs(db, pre, params.tags);
         return pre;
     },
-    expectedDelta(_pre, params) {
+    expectedDelta(pre, params) {
         return {
             mode: "update",
             uuid: params.uuid,
-            assert: [{ field: "tags", equals: sortedTags(params.tags) }],
+            assert: [{ field: "tags", equals: sortedTags(pre.resolvedTagTitles) }],
         };
     },
-    compile(params, vector, _pre, ctx) {
+    compile(params, vector, pre, ctx) {
+        const applied = pre.resolvedTagTitles;
         if (vector === "url-scheme") {
-            return thingsUrl("update", { id: params.uuid, tags: params.tags.join(",") }, ctx.token);
+            return thingsUrl("update", { id: params.uuid, tags: applied.join(",") }, ctx.token);
         }
-        return osa(`set tag names of to do id ${q(params.uuid)} to ${q(params.tags.join(", "))}`);
+        return osa(`set tag names of to do id ${q(params.uuid)} to ${q(applied.join(", "))}`);
     },
 };
 /** Normalize the string | spec union; decide whether states force the json form. */
@@ -516,6 +563,7 @@ const projectAdd = {
         const pre = emptyPreState();
         if (containerGiven(params.area))
             pre.destArea = resolveArea(db, params.area);
+        pre.sameTitleUuids = sameTitleTaskUuids(db, params.title, "project");
         return pre;
     },
     expectedDelta(pre, params, ctx) {
@@ -531,7 +579,12 @@ const projectAdd = {
             assert.push({ field: "area.uuid", equals: area.uuid });
         return {
             mode: "create",
-            probe: { title: params.title, type: "project", sinceEpoch: ctx.nowEpoch - 2 },
+            probe: {
+                title: params.title,
+                type: "project",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+            },
             assert,
         };
     },
@@ -602,24 +655,25 @@ const projectSetTags = {
     preRead(db, params) {
         const pre = emptyPreState();
         pre.target = loadTarget(db, params.uuid);
-        pre.missingTags = missingTagTitles(db, params.tags);
+        applyTagRefs(db, pre, params.tags);
         return pre;
     },
-    expectedDelta(_pre, params) {
+    expectedDelta(pre, params) {
         return {
             mode: "update",
             uuid: params.uuid,
-            assert: [{ field: "tags", equals: sortedTags(params.tags) }],
+            assert: [{ field: "tags", equals: sortedTags(pre.resolvedTagTitles) }],
         };
     },
-    compile(params, vector, _pre, ctx) {
+    compile(params, vector, pre, ctx) {
         // Both vectors validated on projects (A1 URL, A2 AppleScript). Full
         // replacement semantics mirror todo.set-tags; unknown tags are guarded
         // pre-write (the app silently drops them).
+        const applied = pre.resolvedTagTitles;
         if (vector === "url-scheme") {
-            return thingsUrl("update-project", { id: params.uuid, tags: params.tags.join(",") }, ctx.token);
+            return thingsUrl("update-project", { id: params.uuid, tags: applied.join(",") }, ctx.token);
         }
-        return osa(`set tag names of project id ${q(params.uuid)} to ${q(params.tags.join(", "))}`);
+        return osa(`set tag names of project id ${q(params.uuid)} to ${q(applied.join(", "))}`);
     },
 };
 const projectMove = {
@@ -665,7 +719,7 @@ const projectMove = {
 };
 const todoRestore = {
     op: "todo.restore",
-    hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
+    hazards: ["H-UNKNOWN-DESTINATION", "H-TEMPLATE-CHILD-RESTORE", "H-REPEAT-SCHEDULE"],
     preRead(db, params) {
         const pre = emptyPreState();
         pre.target = loadTarget(db, params.uuid);
@@ -695,17 +749,24 @@ const projectDuplicate = {
     preRead(db, params) {
         const pre = emptyPreState();
         pre.target = loadTarget(db, params.uuid);
+        pre.sameTitleUuids = sameTitleTaskUuids(db, nonHeadingTitle(pre), "project");
         return pre;
     },
     expectedDelta(pre, _params, ctx) {
         // E17: the copy carries the title, notes AND children; discover it with
-        // the create probe (fresh creationDate, same as the to-do path E07).
+        // the create probe (fresh creationDate, same as the to-do path E07). The
+        // ORIGINAL shares the copy's title, so it is among the excluded pre-existing
+        // rows — discovery lands on the copy, never the source.
         const target = pre.target;
-        const title = target !== null && target.type !== "heading" ? target.title : "";
         const notes = target !== null && target.type !== "heading" ? target.notes : "";
         return {
             mode: "create",
-            probe: { title, type: "project", sinceEpoch: ctx.nowEpoch - 2 },
+            probe: {
+                title: nonHeadingTitle(pre),
+                type: "project",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+            },
             assert: [{ field: "notes", equals: notes }],
         };
     },
@@ -861,7 +922,7 @@ const areaAdd = {
     preRead(db, params) {
         const pre = emptyPreState();
         if (params.tags !== undefined)
-            pre.missingTags = missingTagTitles(db, params.tags);
+            applyTagRefs(db, pre, params.tags);
         pre.existingEntityUuids = db.prepare("SELECT uuid FROM TMArea WHERE title = ? COLLATE NOCASE").all(params.title).map((r) => r.uuid);
         return pre;
     },
@@ -871,9 +932,13 @@ const areaAdd = {
             entity: "area",
             title: params.title,
             excludeUuids: pre.existingEntityUuids,
+            // Assert the landed tag set on the created area — the app silently
+            // drops unknowns (guarded pre-write), so the created row must carry
+            // exactly the resolved titles (parity with the other tag-set ops).
+            ...(params.tags !== undefined && { assertTags: sortedTags(pre.resolvedTagTitles) }),
         };
     },
-    compile(params, vector) {
+    compile(params, vector, pre) {
         if (vector !== "applescript")
             unsupportedVector(this.op, vector);
         const make = `make new area with properties {name:${q(params.title)}}`;
@@ -881,7 +946,7 @@ const areaAdd = {
             return osa(make);
         const payload = `tell application "Things3"\n` +
             `  ${make}\n` +
-            `  set tag names of area ${q(params.title)} to ${q(params.tags.join(", "))}\n` +
+            `  set tag names of area ${q(params.title)} to ${q(pre.resolvedTagTitles.join(", "))}\n` +
             `end tell`;
         return { vector: "applescript", kind: "osascript", payload, redactedPayload: payload };
     },
@@ -966,17 +1031,23 @@ const todoDuplicate = {
     preRead(db, params) {
         const pre = emptyPreState();
         pre.target = loadTarget(db, params.uuid);
+        pre.sameTitleUuids = sameTitleTaskUuids(db, nonHeadingTitle(pre), "to-do");
         return pre;
     },
     expectedDelta(pre, _params, ctx) {
         // The copy carries the same title/notes with a fresh uuid + creationDate
-        // (E07) — discover it with the create probe, assert copy fidelity.
+        // (E07) — discover it with the create probe, assert copy fidelity. The
+        // ORIGINAL shares the title, so it is excluded as a pre-existing row.
         const target = pre.target;
-        const title = target !== null && target.type !== "heading" ? target.title : "";
         const notes = target !== null && target.type !== "heading" ? target.notes : "";
         return {
             mode: "create",
-            probe: { title, type: "to-do", sinceEpoch: ctx.nowEpoch - 2 },
+            probe: {
+                title: nonHeadingTitle(pre),
+                type: "to-do",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+            },
             assert: [{ field: "notes", equals: notes }],
         };
     },
@@ -997,15 +1068,16 @@ const areaUpdate = {
         const pre = emptyPreState();
         pre.entityTarget = resolveArea(db, { title: params.target, uuid: params.target });
         if (params.tags !== undefined)
-            pre.missingTags = missingTagTitles(db, params.tags);
+            applyTagRefs(db, pre, params.tags);
         return pre;
     },
     expectedDelta(pre, params) {
         const assert = [];
         if (params.title !== undefined)
             assert.push({ field: "title", equals: params.title });
-        if (params.tags !== undefined)
-            assert.push({ field: "tags", equals: sortedTags(params.tags) });
+        if (params.tags !== undefined) {
+            assert.push({ field: "tags", equals: sortedTags(pre.resolvedTagTitles) });
+        }
         return {
             mode: "entity-updated",
             entity: "area",
@@ -1021,7 +1093,7 @@ const areaUpdate = {
         if (params.title !== undefined)
             lines.push(`set name of area id ${id} to ${q(params.title)}`);
         if (params.tags !== undefined) {
-            lines.push(`set tag names of area id ${id} to ${q(params.tags.join(", "))}`);
+            lines.push(`set tag names of area id ${id} to ${q(pre.resolvedTagTitles.join(", "))}`);
         }
         if (lines.length === 1)
             return osa(lines[0]);
@@ -1180,6 +1252,18 @@ function asDateBlock(varName, iso) {
         `set day of ${varName} to ${d}`,
     ];
 }
+/**
+ * Local noon -> UTC instant, so the stored timestamp decodes back to the
+ * requested local DATE in every timezone (P4d: json attrs honored exactly).
+ * WITHOUT milliseconds: the app's json date parser rejects fractional
+ * seconds — a `.000Z` timestamp fails the whole command (error modal, no
+ * write; caught live by the e2e 2026-07-09 — P4d's validated shape was
+ * second-precision).
+ */
+function utcNoon(iso) {
+    const [y, m, d] = iso.split("-").map(Number);
+    return new Date(y ?? 0, (m ?? 1) - 1, d ?? 1, 12, 0, 0).toISOString().replace(/\.\d{3}Z$/, "Z");
+}
 const todoBackdate = {
     op: "todo.backdate",
     hazards: ["H-UNKNOWN-DESTINATION", "H-BACKDATE-OPEN"],
@@ -1223,7 +1307,7 @@ const todoAddLogged = {
             throw new RangeError("creationDate must not be after completionDate");
         }
         const pre = emptyPreState();
-        pre.sameTitleUuids = db.prepare("SELECT uuid FROM TMTask WHERE title = ? AND type = 0").all(params.title).map((r) => r.uuid);
+        pre.sameTitleUuids = sameTitleTaskUuids(db, params.title, "to-do");
         return pre;
     },
     expectedDelta(pre, params) {
@@ -1250,18 +1334,6 @@ const todoAddLogged = {
     compile(params, vector, _pre, ctx) {
         if (vector !== "url-scheme")
             unsupportedVector(this.op, vector);
-        // Local noon -> UTC instant, so the stored timestamp decodes back to the
-        // requested local DATE in every timezone (P4d: json attrs honored exactly).
-        // WITHOUT milliseconds: the app's json date parser rejects fractional
-        // seconds — a `.000Z` timestamp fails the whole command (error modal, no
-        // write; caught live by the e2e 2026-07-09 — P4d's validated shape was
-        // second-precision).
-        const utcNoon = (iso) => {
-            const [y, m, d] = iso.split("-").map(Number);
-            return new Date(y ?? 0, (m ?? 1) - 1, d ?? 1, 12, 0, 0)
-                .toISOString()
-                .replace(/\.\d{3}Z$/, "Z");
-        };
         const payload = JSON.stringify([
             {
                 type: "to-do",
@@ -1395,15 +1467,21 @@ const headingCreate = {
     preRead(db, params) {
         const pre = emptyPreState();
         pre.destProject = resolveProject(db, params.project);
+        pre.sameTitleUuids = sameTitleTaskUuids(db, params.title, "heading");
         return pre;
     },
     expectedDelta(pre, params, ctx) {
         const project = pre.destProject?.resolved;
-        // A new type=2 row with this title under the project; disambiguate
-        // duplicate titles by newest creationDate (findCreated orders DESC).
+        // A new type=2 row with this title under the project; a pre-existing
+        // same-title heading is excluded so discovery cannot bind to it.
         return {
             mode: "create",
-            probe: { title: params.title, type: "heading", sinceEpoch: ctx.nowEpoch - 2 },
+            probe: {
+                title: params.title,
+                type: "heading",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+            },
             assert: project !== undefined && project !== null
                 ? [{ field: "project.uuid", equals: project.uuid }]
                 : [],
@@ -1453,6 +1531,469 @@ const todoClearDatedReminder = {
         });
     },
 };
+// ------------------------------------------------------- ui (GUI) vector
+/** A compiled Accessibility recipe as a CompiledInvocation (no secrets). */
+function uiDrive(recipe) {
+    const rendered = `ui-drive ${recipe.op} on ${recipe.targetUuid}: ${recipe.steps
+        .map((s) => s.label)
+        .join(" → ")}`;
+    return { vector: "ui", kind: "ui-drive", payload: rendered, redactedPayload: rendered, recipe };
+}
+// Re-exported so make-repeating-project.ts and existing callers keep importing
+// the validator from commands.ts; the implementation + the full combination
+// matrix live in repeat-rule.ts.
+export { assertRepeatRule };
+/**
+ * The extended-vocabulary fields of a rule as a recipe `extras` bag, including
+ * ONLY the keys that are present (exactOptionalPropertyTypes: never set an
+ * optional field to undefined). A bare `{ uuid, frequency, interval }` yields
+ * `{}`, so the recipe drives exactly the certified two-control path.
+ */
+function ruleExtras(params) {
+    return {
+        ...(params.afterCompletion !== undefined && { afterCompletion: params.afterCompletion }),
+        ...(params.weekdays !== undefined && { weekdays: params.weekdays }),
+        ...(params.monthly !== undefined && { monthly: params.monthly }),
+        ...(params.yearly !== undefined && { yearly: params.yearly }),
+        ...(params.ends !== undefined && { ends: params.ends }),
+        ...(params.reminder !== undefined && { reminder: params.reminder }),
+        ...(params.deadline !== undefined && { deadline: params.deadline }),
+        ...(params.startDaysEarlier !== undefined && { startDaysEarlier: params.startDaysEarlier }),
+    };
+}
+/** ui ops all guard existence/type + the H-UI-DRIVE acknowledgement. */
+const UI_HAZARDS = ["H-UNKNOWN-DESTINATION", "H-UI-DRIVE"];
+const todoMakeRepeating = {
+    op: "todo.make-repeating",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        assertRepeatRule(params);
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        pre.sameTitleUuids = sameTitleTaskUuids(db, nonHeadingTitle(pre), "to-do");
+        return pre;
+    },
+    expectedDelta(pre, _params, ctx) {
+        // Identity REPLACEMENT or preserve-as-instance (UI2-a / RSIM-R): a NEW
+        // template row (type=0 with a recurrence rule) is born; the original uuid is
+        // EITHER destroyed OR relinked as the current-occurrence instance. Discover
+        // the template with the create probe (excluding the pre-existing same-title
+        // 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.
+        return {
+            mode: "create",
+            probe: {
+                title: nonHeadingTitle(pre),
+                type: "to-do",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+                ...(pre.target !== null && {
+                    repeating: {
+                        sourceUuid: pre.target.uuid,
+                        fingerprint: buildRepeatingFingerprint(pre.target),
+                    },
+                }),
+            },
+            assert: [{ field: "repeating.isTemplate", equals: true }],
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        return uiDrive(makeRepeatingRecipe(params.uuid, params.frequency, params.interval, ruleExtras(params)));
+    },
+};
+const todoRescheduleRepeat = {
+    op: "todo.reschedule-repeat",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        assertRepeatRule(params);
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // Identity PRESERVED (UI2-b): the same template uuid, rule mutated in
+        // place. Assert the decoded rule's frequency + interval; 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.unit", equals: params.frequency },
+                { field: "repeating.rule.interval", equals: params.interval },
+            ],
+            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)));
+    },
+};
+const todoPauseRepeat = {
+    op: "todo.pause-repeat",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // Pause (UI2-c): rt1_instanceCreationPaused → 1; identity preserved.
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [{ field: "repeating.paused", equals: true }],
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        return uiDrive(pauseRepeatRecipe(params.uuid));
+    },
+};
+const todoResumeRepeat = {
+    op: "todo.resume-repeat",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // Resume (UI2-c): rt1_instanceCreationPaused → 0; identity preserved.
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [{ field: "repeating.paused", equals: false }],
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        return uiDrive(resumeRepeatRecipe(params.uuid));
+    },
+};
+// ------------------------------------------------- repeating-PROJECT ops
+// The project analogs of reschedule/pause/resume. Same recurrence codec and
+// Repeat dialog as the to-do ops (identical DB deltas), reached through the
+// project view's always-visible repeat bar (UIC2). No project.stop-repeat is
+// built — the project Stop then selecting the demoted project crashes Things
+// (CRASH1 / oddities §7 C5).
+const projectRescheduleRepeat = {
+    op: "project.reschedule-repeat",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        assertRepeatRule(params);
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // Identity PRESERVED (UIC2-a): same project uuid, rule mutated in place;
+        // capture the prior rule (+ deadline flag) for the faithful undo.
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [
+                { field: "repeating.rule.unit", equals: params.frequency },
+                { field: "repeating.rule.interval", equals: params.interval },
+            ],
+            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)));
+    },
+};
+const projectPauseRepeat = {
+    op: "project.pause-repeat",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // Pause (UIC2-a): rt1_instanceCreationPaused → 1; identity preserved.
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [{ field: "repeating.paused", equals: true }],
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        return uiDrive(projectPauseRepeatRecipe(params.uuid));
+    },
+};
+const projectResumeRepeat = {
+    op: "project.resume-repeat",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // Resume (UIC2-a): rt1_instanceCreationPaused → 0; identity preserved.
+        return {
+            mode: "update",
+            uuid: params.uuid,
+            assert: [{ field: "repeating.paused", equals: false }],
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        return uiDrive(projectResumeRepeatRecipe(params.uuid));
+    },
+};
+// 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,
+// 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).
+const projectMakeRepeating = {
+    op: "project.make-repeating",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-PROJECT-REPEAT", "H-UI-DRIVE"],
+    preRead(db, params) {
+        assertRepeatRule(params);
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        pre.projectRepeat = classifyProjectRepeat(db, pre.target);
+        pre.sameTitleUuids = sameTitleTaskUuids(db, nonHeadingTitle(pre), "project");
+        if (pre.target !== null)
+            pre.repeatSubtreeUuids = projectSubtreeUuids(db, pre.target.uuid);
+        return pre;
+    },
+    expectedDelta(pre, _params, ctx) {
+        // Identity REPLACEMENT or preserve-as-instance (UIC4-b / RSIM-R): a NEW
+        // template project (with a recurrence rule) is born; the source project is
+        // EITHER destroyed OR (when its subtree holds a nested repeater) relinked as
+        // 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.
+        return {
+            mode: "create",
+            probe: {
+                title: nonHeadingTitle(pre),
+                type: "project",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+                ...(pre.target !== null && {
+                    repeating: {
+                        sourceUuid: pre.target.uuid,
+                        fingerprint: buildRepeatingFingerprint(pre.target),
+                        subtreeUuids: pre.repeatSubtreeUuids ?? [],
+                    },
+                }),
+            },
+            assert: [{ field: "repeating.isTemplate", equals: true }],
+        };
+    },
+    compile(params, vector, pre) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        const tax = pre.projectRepeat;
+        if (tax === null || tax.kind === "refuse" || tax.kind === "anytime") {
+            // Unreachable in practice: the guards block refuse/anytime before compile.
+            throw new Error("project.make-repeating: no selectable-row taxonomy resolved (guard bypassed?)");
+        }
+        return uiDrive(projectMakeRepeatingRecipe(tax.containerReveal, params.uuid, tax.title, params.frequency, params.interval, ruleExtras(params)));
+    },
+};
+// project.create-repeating is delivered by the runCreateRepeatingProject
+// orchestrator (project.add THEN project.make-repeating); it has no single
+// atomic surface and is never dispatched directly through the pipeline.
+const CREATE_REPEATING_ORCHESTRATED = "project.create-repeating is delivered by the runCreateRepeatingProject orchestrator (create " +
+    "the project, then promote it to a repeating series); it has no atomic surface and is never " +
+    "dispatched directly through the pipeline";
+const projectCreateRepeating = {
+    op: "project.create-repeating",
+    hazards: [],
+    preRead() {
+        return emptyPreState();
+    },
+    expectedDelta() {
+        throw new Error(CREATE_REPEATING_ORCHESTRATED);
+    },
+    compile() {
+        throw new Error(CREATE_REPEATING_ORCHESTRATED);
+    },
+};
+const todoConvertToProject = {
+    op: "todo.convert-to-project",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        // The new row is a PROJECT (type=1) — exclude pre-existing same-title
+        // projects, not the source to-do (a different type the probe never sees).
+        pre.sameTitleUuids = sameTitleTaskUuids(db, nonHeadingTitle(pre), "project");
+        return pre;
+    },
+    expectedDelta(pre, _params, ctx) {
+        // Identity REPLACEMENT (UI2-d): the to-do uuid dies; a NEW type=1 project
+        // is born, notes preserved. Discover it (its uuid is returned).
+        const target = pre.target;
+        const notes = target !== null && target.type !== "heading" ? target.notes : "";
+        return {
+            mode: "create",
+            probe: {
+                title: nonHeadingTitle(pre),
+                type: "project",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+            },
+            assert: [{ field: "notes", equals: notes }],
+        };
+    },
+    compile(params, vector) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        return uiDrive(convertToProjectRecipe("todo.convert-to-project", params.uuid));
+    },
+};
+const headingConvertToProject = {
+    op: "heading.convert-to-project",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        // The new row is a PROJECT (type=1) carrying the former heading's title;
+        // exclude pre-existing same-title projects. The heading uses its raw title
+        // (headings are not covered by nonHeadingTitle).
+        const title = pre.target !== null ? pre.target.title : "";
+        pre.sameTitleUuids = sameTitleTaskUuids(db, title, "project");
+        pre.headingConvert = classifyHeadingConvert(db, pre.target);
+        return pre;
+    },
+    expectedDelta(pre, _params, ctx) {
+        // Identity REPLACEMENT (UI2-d): the heading uuid dies; a NEW type=1
+        // project is born (promoted into the parent project's area, children
+        // reparented). Discover the new project by its (former heading) title.
+        const target = pre.target;
+        const title = target !== null ? target.title : "";
+        return {
+            mode: "create",
+            probe: {
+                title,
+                type: "project",
+                sinceEpoch: ctx.nowEpoch - 2,
+                excludeUuids: pre.sameTitleUuids,
+            },
+            assert: [],
+        };
+    },
+    compile(_params, vector, pre) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        const tax = pre.headingConvert;
+        if (tax === null || tax.kind === "refuse") {
+            // H-UNKNOWN-DESTINATION blocks a non-heading target before compile; a
+            // refuse here means a parentless heading (or one absent from its project's
+            // heading set) slipped past — fail loud rather than drive the wrong row.
+            throw new Error(`heading.convert-to-project: ${tax?.kind === "refuse" ? tax.detail : "no heading taxonomy resolved (guard bypassed?)"}`);
+        }
+        return uiDrive(headingConvertToProjectRecipe(tax.projectReveal, tax.ordinal));
+    },
+};
+// -------------------------------------------------- sidebar AREA reorder
+/** The compile-time placement for area.reorder (resolved refs). */
+function sidebarPlacementOf(params, pre) {
+    const ref = pre.destArea?.resolved;
+    if (params.before !== undefined && ref != null) {
+        return { kind: "before", uuid: ref.uuid, title: ref.title };
+    }
+    if (params.after !== undefined && ref != null) {
+        return { kind: "after", uuid: ref.uuid, title: ref.title };
+    }
+    return { kind: params.position === "first" ? "first" : "last" };
+}
+const areaReorderSidebar = {
+    op: "area.reorder",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-UI-DRIVE"],
+    preRead(db, params) {
+        const destinations = [params.before, params.after, params.position].filter((d) => d !== undefined);
+        if (destinations.length !== 1) {
+            throw new RangeError("pass exactly one destination: before, after, or position (first | last)");
+        }
+        if (params.position !== undefined &&
+            params.position !== "first" &&
+            params.position !== "last") {
+            throw new RangeError(`invalid position "${params.position}" — expected first | last`);
+        }
+        const pre = emptyPreState();
+        pre.entityTarget = resolveArea(db, { uuid: params.target, title: params.target });
+        const ref = params.before ?? params.after;
+        if (ref !== undefined)
+            pre.destArea = resolveArea(db, { uuid: ref, title: ref });
+        const target = pre.entityTarget.resolved;
+        const dest = pre.destArea?.resolved;
+        if (target != null && dest != null && target.uuid === dest.uuid) {
+            throw new RangeError("the destination area is the area being moved");
+        }
+        // The sidebar drag addresses rows by their VISIBLE NAME — a duplicated
+        // area title makes the row ambiguous, so refuse up front.
+        for (const area of [target, dest]) {
+            if (area == null)
+                continue;
+            const dup = db
+                .prepare("SELECT COUNT(*) AS n FROM TMArea WHERE title = ? COLLATE NOCASE")
+                .get(area.title);
+            if (dup.n > 1) {
+                throw new RangeError(`area title "${area.title}" is shared by ${dup.n} areas — the sidebar move addresses ` +
+                    "areas by their visible name; rename one first");
+            }
+        }
+        pre.areaOrder = db.prepare(`SELECT uuid FROM TMArea ORDER BY "index", uuid`).all().map((r) => r.uuid);
+        return pre;
+    },
+    expectedDelta(pre, params) {
+        const target = pre.entityTarget?.resolved?.uuid ?? "";
+        const order = (pre.areaOrder ?? []).filter((u) => u !== target);
+        const refUuid = pre.destArea?.resolved?.uuid;
+        // Assert the implicated RELATIVE pair (index VALUES are never asserted —
+        // a drag may renumber a neighbor, AXDRAG1-a); capture the FULL pre-order
+        // for undo.
+        let sequence;
+        if (params.before !== undefined && refUuid !== undefined) {
+            sequence = [target, refUuid];
+        }
+        else if (params.after !== undefined && refUuid !== undefined) {
+            sequence = [refUuid, target];
+        }
+        else if (params.position === "first") {
+            const first = order[0];
+            sequence = first === undefined ? [target] : [target, first];
+        }
+        else {
+            const last = order.at(-1);
+            sequence = last === undefined ? [target] : [last, target];
+        }
+        return {
+            mode: "ordering",
+            key: "area-index",
+            sequence,
+            capture: pre.areaOrder ?? sequence,
+            subject: target,
+        };
+    },
+    compile(params, vector, pre) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        const target = pre.entityTarget?.resolved;
+        return uiDrive(areaReorderSidebarRecipe({ uuid: target?.uuid ?? "", title: target?.title ?? "" }, sidebarPlacementOf(params, pre)));
+    },
+};
 const trashEmpty = {
     op: "trash.empty",
     hazards: ["H-PERMANENT-DELETE"],
@@ -1508,5 +2049,17 @@ export const COMMANDS = {
     "heading.unarchive": headingUnarchive,
     "heading.create": headingCreate,
     "todo.clear-dated-reminder": todoClearDatedReminder,
+    "todo.make-repeating": todoMakeRepeating,
+    "todo.reschedule-repeat": todoRescheduleRepeat,
+    "todo.pause-repeat": todoPauseRepeat,
+    "todo.resume-repeat": todoResumeRepeat,
+    "todo.convert-to-project": todoConvertToProject,
+    "heading.convert-to-project": headingConvertToProject,
+    "project.reschedule-repeat": projectRescheduleRepeat,
+    "project.pause-repeat": projectPauseRepeat,
+    "project.resume-repeat": projectResumeRepeat,
+    "area.reorder": areaReorderSidebar,
+    "project.make-repeating": projectMakeRepeating,
+    "project.create-repeating": projectCreateRepeating,
 };
 //# sourceMappingURL=commands.js.map