things-api 0.10.0 → 0.12.0

package/dist/write/commands.js

@@ -1,11 +1,14 @@
-import { decodeReminderTime, encodeReminderTime, reminderUrlToken, } from "../model/dates.js";
+import { decodeReminderTime, encodeReminderTime, localToday, reminderUrlToken, } from "../model/dates.js";
 import { byUuid } from "../read/detail.js";
-import { childTagTitles, classifyProjectRepeat, computeReorderPre, emptyPreState, loadTarget, projectChildren, projectStatus, resolveArea, resolveHeading, resolveProject, resolveTag, sameTitleTaskUuids, trashedCount, } from "./pre-state.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 { 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, makeRepeatingRecipe, pauseRepeatRecipe, projectMakeRepeatingRecipe, projectPauseRepeatRecipe, projectRescheduleRepeatRecipe, projectResumeRepeatRecipe, rescheduleRepeatRecipe, resumeRepeatRecipe, } from "./vectors/ui-recipes.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";
 // ------------------------------------------------------------------ helpers
 function thingsUrl(command, params, token) {
     const parts = [];
@@ -152,6 +155,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);
@@ -229,6 +238,14 @@ const todoAdd = {
  * `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.
  */
 function effectiveReminder(pre, params) {
     if (params.reminder !== undefined)
@@ -242,6 +259,8 @@ function effectiveReminder(pre, params) {
     const target = pre.target;
     if (target === null || target.type === "heading")
         return null;
+    if (!reminderIsLive(target.startDate, pre.todayIso))
+        return null;
     return target.reminder;
 }
 function assertNotesModesExclusive(params) {
@@ -268,9 +287,10 @@ function expectedNotes(pre, params) {
 const todoUpdate = {
     op: "todo.update",
     hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE", "H-REMINDER-SCOPE"],
-    preRead(db, params) {
+    preRead(db, params, now) {
         assertNotesModesExclusive(params);
         const pre = emptyPreState();
+        pre.todayIso = localToday(now);
         pre.target = loadTarget(db, params.uuid);
         return pre;
     },
@@ -344,11 +364,21 @@ const todoMove = {
     ],
     preRead(db, params) {
         const container = containerGiven(params.project) || containerGiven(params.area) || params.heading !== undefined;
-        if (params.inbox === true && (container || params.detach === true)) {
-            throw new RangeError("inbox is exclusive with project/area/heading/detach");
+        const detachFamily = params.loose === true || params.noHeading === true;
+        if (params.inbox === true && (container || detachFamily)) {
+            throw new RangeError("inbox is exclusive with project/area/heading and --no-heading/--loose");
         }
-        if (params.detach === true && container) {
-            throw new RangeError("detach is exclusive with project/area/heading destinations");
+        if (params.loose === true && (container || params.noHeading === true)) {
+            throw new RangeError("--loose is exclusive with project/area/heading and --no-heading");
+        }
+        if (params.noHeading === true && container) {
+            throw new RangeError("--no-heading 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);
@@ -361,6 +391,16 @@ const todoMove = {
                 }
             }
         }
+        // --no-heading re-asserts the CURRENT project as the container: resolve the
+        // target's own project (direct or via its heading) so compile/delta pin it.
+        if (params.noHeading === true) {
+            const t = pre.target;
+            const current = t !== null && t.type === "to-do" ? (t.project ?? t.headingProject ?? null) : null;
+            if (current !== null) {
+                pre.destProject = { resolved: { uuid: current.uuid, title: current.title }, matches: 1 };
+                pre.destProjectStatus = projectStatus(db, current.uuid);
+            }
+        }
         if (containerGiven(params.area))
             pre.destArea = resolveArea(db, params.area);
         return pre;
@@ -372,7 +412,7 @@ const todoMove = {
             assert.push({ field: "start", equals: "inbox" }, { field: "startDate", equals: null });
             return { mode: "update", uuid: params.uuid, assert };
         }
-        if (params.detach === true) {
+        if (params.loose === true) {
             // P21/P22: empty list-id strips every container link; the schedule is
             // untouched (pin it — a silent de-schedule would be a contrary write).
             const target = pre.target;
@@ -380,6 +420,16 @@ const todoMove = {
             assert.push({ field: "project", equals: null }, { field: "area", equals: null }, { field: "heading", equals: null }, { field: "startDate", equals: startDate });
             return { mode: "update", uuid: params.uuid, assert };
         }
+        if (params.noHeading === true) {
+            // Leave the heading, keep the project: re-assert the current project as
+            // the container with no heading (lands in the unheaded block).
+            const project = pre.destProject?.resolved;
+            assert.push({ field: "heading", equals: null });
+            if (project !== undefined && project !== null) {
+                assert.push({ field: "project.uuid", equals: project.uuid });
+            }
+            return { mode: "update", uuid: params.uuid, assert };
+        }
         const heading = pre.destHeading?.resolved;
         const project = pre.destProject?.resolved;
         const area = pre.destArea?.resolved;
@@ -402,13 +452,20 @@ const todoMove = {
                 unsupportedVector(this.op, vector);
             return osa(`move to do id ${q(params.uuid)} to list "Inbox"`);
         }
-        if (params.detach === true) {
+        if (params.loose === true) {
             // Empty list-id = clear the container (P21/P22) — URL only; the other
             // vectors reject or silently ignore container removal (P10/P11, P26).
             if (vector !== "url-scheme")
                 unsupportedVector(this.op, vector);
             return thingsUrl("update", { id: params.uuid, "list-id": "" }, ctx.token);
         }
+        if (params.noHeading === true) {
+            // Re-assert the CURRENT project as the list with no heading param — the
+            // to-do drops its heading FK and lands in the project's unheaded block.
+            if (vector !== "url-scheme")
+                unsupportedVector(this.op, vector);
+            return thingsUrl("update", { id: params.uuid, "list-id": pre.destProject?.resolved?.uuid ?? "" }, ctx.token);
+        }
         const project = pre.destProject?.resolved;
         const area = pre.destArea?.resolved;
         if (vector === "url-scheme") {
@@ -591,9 +648,10 @@ const projectAdd = {
 const projectUpdate = {
     op: "project.update",
     hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE", "H-REMINDER-SCOPE"],
-    preRead(db, params) {
+    preRead(db, params, now) {
         assertNotesModesExclusive(params);
         const pre = emptyPreState();
+        pre.todayIso = localToday(now);
         pre.target = loadTarget(db, params.uuid);
         return pre;
     },
@@ -667,8 +725,8 @@ const projectMove = {
     op: "project.move",
     hazards: ["H-UNKNOWN-DESTINATION", "H-REPEAT-SCHEDULE"],
     preRead(db, params) {
-        if ((params.detach === true) === containerGiven(params.area)) {
-            throw new RangeError("project.move needs exactly one of area / detach");
+        if ((params.noArea === true) === containerGiven(params.area)) {
+            throw new RangeError("project.move needs exactly one of area / --no-area");
         }
         const pre = emptyPreState();
         pre.target = loadTarget(db, params.uuid);
@@ -683,7 +741,7 @@ const projectMove = {
             mode: "update",
             uuid: params.uuid,
             assert: [
-                params.detach === true
+                params.noArea === true
                     ? { field: "area", equals: null }
                     : { field: "area.uuid", equals: pre.destArea?.resolved?.uuid ?? "" },
             ],
@@ -691,14 +749,14 @@ const projectMove = {
     },
     compile(params, vector, pre, ctx) {
         if (vector === "url-scheme") {
-            // P23 (move) / P24 (empty area-id = detach — URL is the ONLY detach
+            // P23 (move) / P24 (empty area-id = leave the area — URL is the ONLY
             // surface: AppleScript rejects missing value/"" and json-null no-ops).
             return thingsUrl("update-project", {
                 id: params.uuid,
-                "area-id": params.detach === true ? "" : (pre.destArea?.resolved?.uuid ?? ""),
+                "area-id": params.noArea === true ? "" : (pre.destArea?.resolved?.uuid ?? ""),
             }, ctx.token);
         }
-        if (params.detach === true)
+        if (params.noArea === true)
             unsupportedVector(this.op, vector);
         return osa(`set area of project id ${q(params.uuid)} to area id ` +
             q(pre.destArea?.resolved?.uuid ?? ""));
@@ -706,7 +764,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);
@@ -940,10 +998,13 @@ const areaAdd = {
 };
 const areaDelete = {
     op: "area.delete",
-    hazards: ["H-UNKNOWN-DESTINATION", "H-PERMANENT-DELETE"],
+    hazards: ["H-UNKNOWN-DESTINATION", "H-AREA-NOT-EMPTY", "H-PERMANENT-DELETE"],
     preRead(db, params) {
         const pre = emptyPreState();
         pre.entityTarget = resolveArea(db, { title: params.target, uuid: params.target });
+        if (pre.entityTarget.resolved !== null) {
+            pre.areaMembers = areaMemberCounts(db, pre.entityTarget.resolved.uuid);
+        }
         return pre;
     },
     expectedDelta(pre) {
@@ -1171,7 +1232,7 @@ const reorder = {
     preRead(db, params, now) {
         const pre = emptyPreState();
         let containerUuid = null;
-        if (params.scope === "project" || params.scope === "headings") {
+        if (params.scope === "project") {
             pre.destProject = resolveProject(db, params.container ?? {});
             containerUuid = pre.destProject.resolved?.uuid ?? null;
         }
@@ -1179,6 +1240,20 @@ const reorder = {
             pre.destArea = resolveArea(db, params.container ?? {});
             containerUuid = pre.destArea.resolved?.uuid ?? null;
         }
+        if (params.scope === "container-day") {
+            // The container may be a project OR an area (DAYORD-b); resolve whichever
+            // the ref names so the compile can pick the right `project id`/`area id`
+            // specifier. The planner always passes a resolved uuid.
+            const asProject = resolveProject(db, params.container ?? {});
+            if (asProject.resolved !== null) {
+                pre.destProject = asProject;
+                containerUuid = asProject.resolved.uuid;
+            }
+            else {
+                pre.destArea = resolveArea(db, params.container ?? {});
+                containerUuid = pre.destArea.resolved?.uuid ?? null;
+            }
+        }
         pre.reorder = computeReorderPre(db, params, containerUuid, now);
         return pre;
     },
@@ -1196,15 +1271,22 @@ const reorder = {
     compile(params, vector, pre) {
         if (vector !== "applescript")
             unsupportedVector(this.op, vector);
-        const specifier = params.scope === "project" || params.scope === "headings"
+        const containerDaySpecifier = pre.destProject?.resolved != null
+            ? `project id ${q(pre.destProject.resolved.uuid)}`
+            : `area id ${q(pre.destArea?.resolved?.uuid ?? "")}`;
+        const specifier = params.scope === "project"
             ? `project id ${q(pre.destProject?.resolved?.uuid ?? "")}`
             : params.scope === "area"
                 ? `area id ${q(pre.destArea?.resolved?.uuid ?? "")}`
-                : params.scope === "inbox"
-                    ? `list "Inbox"`
-                    : params.scope === "someday"
-                        ? `list "Someday"`
-                        : `list "Today"`;
+                : params.scope === "container-day"
+                    ? containerDaySpecifier
+                    : params.scope === "inbox"
+                        ? `list "Inbox"`
+                        : params.scope === "someday"
+                            ? `list "Someday"`
+                            : params.scope === "tomorrow"
+                                ? `list "Tomorrow"`
+                                : `list "Today"`;
         const wire = pre.reorder?.wireList ?? params.uuids;
         if (params.scope === "someday") {
             // The Someday handler STACKS each sent id above the list's current top
@@ -1352,7 +1434,7 @@ function headingChildren(db, headingUuid) {
     return todos;
 }
 const headingRename = {
-    op: "heading.rename",
+    op: "project.rename-heading",
     hazards: ["H-UNKNOWN-DESTINATION"],
     preRead(db, params) {
         const pre = emptyPreState();
@@ -1375,7 +1457,7 @@ const headingRename = {
     },
 };
 const headingArchive = {
-    op: "heading.archive",
+    op: "project.archive-heading",
     hazards: ["H-UNKNOWN-DESTINATION", "H-HEADING-CHILDREN"],
     preRead(db, params) {
         const pre = emptyPreState();
@@ -1428,7 +1510,7 @@ const headingArchive = {
     },
 };
 const headingUnarchive = {
-    op: "heading.unarchive",
+    op: "project.unarchive-heading",
     hazards: ["H-UNKNOWN-DESTINATION"],
     preRead(db, params) {
         const pre = emptyPreState();
@@ -1448,8 +1530,8 @@ const headingUnarchive = {
         return osa(`set status of to do id ${q(params.uuid)} to open`);
     },
 };
-const headingCreate = {
-    op: "heading.create",
+const headingAdd = {
+    op: "project.add-heading",
     hazards: ["H-UNKNOWN-DESTINATION"],
     preRead(db, params) {
         const pre = emptyPreState();
@@ -1484,6 +1566,32 @@ const headingCreate = {
         });
     },
 };
+const projectMoveHeading = {
+    op: "project.move-heading",
+    hazards: ["H-UNKNOWN-DESTINATION", "H-HEADING-ORDER"],
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.destProject = resolveProject(db, params.project);
+        pre.headingMove = computeHeadingMovePre(db, pre.destProject, params.headings, params.placement);
+        return pre;
+    },
+    expectedDelta(pre) {
+        // The reorder wire re-ranks the FULL heading list; verify the whole target
+        // order (strictly ascending "index"). Children follow their heading (scf
+        // P1), so no per-child assertion is needed.
+        return { mode: "ordering", key: "index", sequence: pre.headingMove?.targetOrder ?? [] };
+    },
+    compile(_params, vector, pre) {
+        // The same native private-reorder wire the old `reorder --scope headings`
+        // used (experimental — gated by allow-experimental + the sdef canary),
+        // fed the computed full order.
+        if (vector !== "applescript")
+            unsupportedVector(this.op, vector);
+        const order = pre.headingMove?.targetOrder ?? [];
+        return osa(`${PRIVATE_REORDER_COMMAND} project id ${q(pre.destProject?.resolved?.uuid ?? "")} ` +
+            `with ids ${q(order.join(","))}`);
+    },
+};
 const todoClearDatedReminder = {
     op: "todo.clear-dated-reminder",
     hazards: ["H-UNKNOWN-DESTINATION", "H-NO-REMINDER"],
@@ -1560,12 +1668,17 @@ const todoMakeRepeating = {
         pre.sameTitleUuids = sameTitleTaskUuids(db, nonHeadingTitle(pre), "to-do");
         return pre;
     },
-    expectedDelta(pre, _params, ctx) {
-        // Identity REPLACEMENT (UI2-a): the original to-do uuid dies; a NEW
-        // template row (type=0 with a recurrence rule) is born alongside a spawned
-        // instance sharing its title. Discover the template with the create probe,
-        // excluding the pre-existing same-title rows (incl. the dying original), and
-        // pick the template (not the spawned instance) by asserting it IS one.
+    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. `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.
         return {
             mode: "create",
             probe: {
@@ -1573,6 +1686,17 @@ const todoMakeRepeating = {
                 type: "to-do",
                 sinceEpoch: ctx.nowEpoch - 2,
                 excludeUuids: pre.sameTitleUuids,
+                ...(pre.target !== null && {
+                    repeating: {
+                        sourceUuid: pre.target.uuid,
+                        fingerprint: buildRepeatingFingerprint(pre.target),
+                        expectedRule: {
+                            type: params.afterCompletion === true ? "after-completion" : "fixed",
+                            unit: params.frequency,
+                            interval: params.interval,
+                        },
+                    },
+                }),
             },
             assert: [{ field: "repeating.isTemplate", equals: true }],
         };
@@ -1594,12 +1718,22 @@ const todoRescheduleRepeat = {
     },
     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.
+        // 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.
         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 },
             ],
@@ -1673,11 +1807,17 @@ 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.
+        // 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.
         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 },
             ],
@@ -1749,14 +1889,18 @@ const projectMakeRepeating = {
         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 (UIC4-b): the original project uuid dies; a NEW
-        // template project (with a recurrence rule) is born alongside a spawned
-        // instance sharing its title. Pick the TEMPLATE by asserting it IS one
-        // (area preserved), excluding the pre-existing same-title rows so discovery
-        // cannot bind to the spawned instance or the dying original.
+    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.
+        // `expectedRule` makes the landed rule verifiable (interval-race guard, §8l).
         return {
             mode: "create",
             probe: {
@@ -1764,6 +1908,18 @@ const projectMakeRepeating = {
                 type: "project",
                 sinceEpoch: ctx.nowEpoch - 2,
                 excludeUuids: pre.sameTitleUuids,
+                ...(pre.target !== null && {
+                    repeating: {
+                        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,
+                        },
+                    },
+                }),
             },
             assert: [{ field: "repeating.isTemplate", equals: true }],
         };
@@ -1779,23 +1935,23 @@ const projectMakeRepeating = {
         return uiDrive(projectMakeRepeatingRecipe(tax.containerReveal, params.uuid, tax.title, params.frequency, params.interval, ruleExtras(params)));
     },
 };
-// project.create-repeating is delivered by the runCreateRepeatingProject
+// project.add-repeating is delivered by the runAddRepeatingProject
 // 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 " +
+const ADD_REPEATING_ORCHESTRATED = "project.add-repeating is delivered by the runAddRepeatingProject 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",
+const projectAddRepeating = {
+    op: "project.add-repeating",
     hazards: [],
     preRead() {
         return emptyPreState();
     },
     expectedDelta() {
-        throw new Error(CREATE_REPEATING_ORCHESTRATED);
+        throw new Error(ADD_REPEATING_ORCHESTRATED);
     },
     compile() {
-        throw new Error(CREATE_REPEATING_ORCHESTRATED);
+        throw new Error(ADD_REPEATING_ORCHESTRATED);
     },
 };
 const todoConvertToProject = {
@@ -1832,7 +1988,7 @@ const todoConvertToProject = {
     },
 };
 const headingConvertToProject = {
-    op: "heading.convert-to-project",
+    op: "project.promote-heading",
     hazards: UI_HAZARDS,
     preRead(db, params) {
         const pre = emptyPreState();
@@ -1842,6 +1998,7 @@ const headingConvertToProject = {
         // (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) {
@@ -1861,10 +2018,82 @@ const headingConvertToProject = {
             assert: [],
         };
     },
-    compile(params, vector) {
+    compile(_params, vector, pre) {
         if (vector !== "ui")
             unsupportedVector(this.op, vector);
-        return uiDrive(convertToProjectRecipe("heading.convert-to-project", params.uuid));
+        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(`project.promote-heading: ${tax?.kind === "refuse" ? tax.detail : "no heading taxonomy resolved (guard bypassed?)"}`);
+        }
+        return uiDrive(headingConvertToProjectRecipe(tax.projectReveal, tax.ordinal));
+    },
+};
+const projectMoveHeadingToProject = {
+    op: "project.move-heading-to-project",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.headingMoveToProject = classifyHeadingMoveToProject(db, params.project, params.heading, params.toProject);
+        if (pre.headingMoveToProject.kind === "ok") {
+            // Load the heading row so the verify oracle reads its (post-op) project FK.
+            pre.target = loadTarget(db, pre.headingMoveToProject.pre.headingUuid);
+        }
+        return pre;
+    },
+    expectedDelta(pre) {
+        // HEADXPROJ: a single-row change — the heading's `project` FK becomes the
+        // destination; its children follow via their intact heading FK (no child
+        // rewrite, no index churn), so no per-child assertion is needed.
+        const tax = pre.headingMoveToProject;
+        const headingUuid = tax?.kind === "ok" ? tax.pre.headingUuid : "";
+        const destUuid = tax?.kind === "ok" ? tax.pre.destProjectUuid : "";
+        return {
+            mode: "update",
+            uuid: headingUuid,
+            assert: [{ field: "project.uuid", equals: destUuid }],
+        };
+    },
+    compile(_params, vector, pre) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        const tax = pre.headingMoveToProject;
+        if (tax === null || tax.kind === "refuse") {
+            // The taxonomy refusals are surfaced by H-UNKNOWN-DESTINATION before
+            // compile; reaching here with one means the guard was bypassed.
+            throw new Error(`project.move-heading-to-project: ${tax?.kind === "refuse" ? tax.detail : "no taxonomy resolved (guard bypassed?)"}`);
+        }
+        return uiDrive(moveHeadingToProjectRecipe(tax.pre.sourceProjectUuid, tax.pre.headingTitle, tax.pre.destProjectTitle));
+    },
+};
+const projectDissolveHeading = {
+    op: "project.dissolve-heading",
+    hazards: UI_HAZARDS,
+    preRead(db, params) {
+        const pre = emptyPreState();
+        pre.target = loadTarget(db, params.uuid);
+        pre.headingDissolve = classifyHeadingDissolve(db, pre.target);
+        return pre;
+    },
+    expectedDelta(_pre, params) {
+        // DISS1: the heading row is HARD-DELETED (removed from TMTask) while its
+        // children become direct project children. The verify oracle is the heading
+        // GONE — its children re-home is the DISS1-locked invariant, checked by the
+        // op's tests (a childless heading dissolve verifies identically).
+        return { mode: "gone", entity: "task", uuid: params.uuid };
+    },
+    compile(_params, vector, pre) {
+        if (vector !== "ui")
+            unsupportedVector(this.op, vector);
+        const tax = pre.headingDissolve;
+        if (tax === null || tax.kind === "refuse") {
+            // The taxonomy refusals are surfaced by H-UNKNOWN-DESTINATION before
+            // compile; reaching here with one means the guard was bypassed.
+            throw new Error(`project.dissolve-heading: ${tax?.kind === "refuse" ? tax.detail : "no taxonomy resolved (guard bypassed?)"}`);
+        }
+        return uiDrive(dissolveHeadingRecipe(tax.pre.projectReveal, tax.pre.headingTitle));
     },
 };
 // -------------------------------------------------- sidebar AREA reorder
@@ -1892,6 +2121,16 @@ const areaReorderSidebar = {
             params.position !== "last") {
             throw new RangeError(`invalid position "${params.position}" — expected first | last`);
         }
+        // The reserved `loose` pseudo-area ref (the derived area-less view) has no
+        // sidebar row, so it can be neither moved nor an anchor — refuse it by name
+        // with a specific message rather than a generic no-such-area error, matching
+        // the loose-pseudo-area write-refusal pattern (src/read/pseudo-area.ts).
+        for (const ref of [params.target, params.before, params.after]) {
+            if (ref !== undefined && isLooseRef(ref)) {
+                throw new RangeError("the loose pseudo-area is a derived view — it has no sidebar row and cannot be " +
+                    "reordered");
+            }
+        }
         const pre = emptyPreState();
         pre.entityTarget = resolveArea(db, { uuid: params.target, title: params.target });
         const ref = params.before ?? params.after;
@@ -1902,17 +2141,25 @@ const areaReorderSidebar = {
         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.
+        // The sidebar drag addresses rows by their VISIBLE NAME. A DUPLICATE area
+        // title is now handled by positional disambiguation in the ui-vector driver
+        // (ORDFIN2 AXDRAG3: the intended uuid's Nth same-titled row is grabbed by the
+        // `(index, uuid)` ASC law, and the post-gesture DB assert + self-invert catch
+        // a wrong grab) — so a uuid-targeted ref whose title is shared is NO LONGER
+        // refused here. A duplicate NAME ref stays refused upstream (resolveArea
+        // returns the ambiguity candidates). Only a SANITY CAP remains: too many
+        // same-titled rows could make the positional grab loop unreliable, so refuse
+        // rather than churn. (WIRED — lab-cert pending an AXDRAG4 VM sitting.)
+        const SAME_TITLE_CAP = 8;
         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");
+            if (dup.n > SAME_TITLE_CAP) {
+                throw new RangeError(`area title "${area.title}" is shared by ${dup.n} areas (over the ${SAME_TITLE_CAP}-row ` +
+                    "positional-disambiguation cap) — rename some, or reorder by a uniquely-titled anchor");
             }
         }
         pre.areaOrder = db.prepare(`SELECT uuid FROM TMArea ORDER BY "index", uuid`).all().map((r) => r.uuid);
@@ -2005,22 +2252,25 @@ export const COMMANDS = {
     "project.set-tags": projectSetTags,
     "todo.backdate": todoBackdate,
     "todo.add-logged": todoAddLogged,
-    "heading.rename": headingRename,
-    "heading.archive": headingArchive,
-    "heading.unarchive": headingUnarchive,
-    "heading.create": headingCreate,
+    "project.add-heading": headingAdd,
+    "project.rename-heading": headingRename,
+    "project.archive-heading": headingArchive,
+    "project.unarchive-heading": headingUnarchive,
+    "project.promote-heading": headingConvertToProject,
+    "project.move-heading": projectMoveHeading,
+    "project.move-heading-to-project": projectMoveHeadingToProject,
+    "project.dissolve-heading": projectDissolveHeading,
     "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,
+    "project.add-repeating": projectAddRepeating,
 };
 //# sourceMappingURL=commands.js.map