things-api 0.12.0 → 0.14.0

package/dist/write/reorder.js

@@ -302,8 +302,19 @@ function bounceFallbackOk(deps, what, kind, protocol) {
         return d;
     return { ...d, fallbackNote: fallbackNoteFor(deps, protocol) };
 }
+/**
+ * Whether the native `_private_experimental_ reorder` command is available — the
+ * config gate is on AND the app still declares it in its sdef (the canary). The
+ * `day`-scope template leg family gates on this too: a repeating TO-DO template's
+ * only safe day-block placement is the native single-id `list "Upcoming"` front-
+ * insert (a dated when= leg CRASHES a template, §1), so a day-group carrying any
+ * template requires the native surface (else it refuses honestly, naming them).
+ */
+function nativeReorderAvailable(deps) {
+    return deps.config.allowExperimental && (deps.sdefProbe ?? sdefDeclaresPrivateReorder)();
+}
 function resolveStrategy(deps, params) {
-    const nativeAvailable = deps.config.allowExperimental && (deps.sdefProbe ?? sdefDeclaresPrivateReorder)();
+    const nativeAvailable = nativeReorderAvailable(deps);
     // Scopes whose ONLY surface is the bounce (no native command reaches them).
     const bounceOnly = {
         evening: { kind: "evening", what: "evening-section order" },
@@ -398,6 +409,11 @@ function resolveStrategy(deps, params) {
         // this case exists only for switch exhaustiveness.
         case "heading-someday":
             return { kind: "ok", strategy: "native" };
+        // `upcoming` is an INTERNAL per-template front-insert leg (the `day` bounce
+        // dispatches it via runMutation directly — TMPLSORT-1); it never reaches the
+        // strategy resolver. Blocked here for exhaustiveness / defence in depth.
+        case "upcoming":
+            return blocked("the `upcoming` scope is an internal per-template front-insert leg, not a user reorder scope", "reorder a template's day-block via `things todo reorder` on its day (the planner routes it)");
     }
 }
 // (The SOMEBNC-project someday-only bounce fallback for the `project` scope is
@@ -483,7 +499,7 @@ async function runHeadingSomeday(deps, params, options) {
     const headingUuid = params.container?.uuid ?? null;
     const projectUuid = headingProjectUuid(deps, headingUuid);
     const txnId = `txn-${startedAt.getTime().toString(36)}-${process.pid.toString(36)}`;
-    const pre = computeReorderPre(deps.db, params, headingUuid, now());
+    const pre = computeReorderPre(deps.db, params, headingUuid, now(), { zone: deps.zone });
     const preRanks = {};
     for (const m of pre.members)
         preRanks[m.uuid] = m.rank;
@@ -620,19 +636,38 @@ async function runBounce(deps, params, bounceKind, options) {
     // The two `when=` leg values. A fixed-bucket bounce uses the spec's keywords; the
     // DATED `day` bounce (SIT4 DAYBNC) derives them from the movees' shared day —
     // back = the day D, away = the neighbour day D+1 (a strictly-future staging day
-    // ≠ D that keeps the transient visit out of Today). The day is read off the first
-    // requested uuid (the planner guarantees every movee shares it); an absent/
-    // malformed day yields an empty member set and is rejected below before any
-    // dispatch, so the today fallback here only keeps the WhenValue well-typed.
+    // ≠ D that keeps the transient visit out of Today). The day D is read off the
+    // first requested uuid — its `startDate` when scheduled, else its `deadline` when
+    // it is a deadline-forecast row (startDate NULL, start IN (1,2) — DLBNC/§9o). The
+    // planner guarantees every movee shares D; an absent/malformed day yields an empty
+    // member set and is rejected below before any dispatch, so the today fallback here
+    // only keeps the WhenValue well-typed. (The `when=` values drive the SCHEDULED
+    // rows' bounce legs; a forecast row ignores them — it rides the deadline-cycle.)
     let dayPacked = null;
     let awayValue;
     let backValue;
     if (spec.dated) {
         const firstUuid = params.uuids[0];
+        const firstRow = firstUuid !== undefined
+            ? deps.db
+                .prepare("SELECT startDate, startBucket, deadline, start, rt1_nextInstanceStartDate AS proj, " +
+                "(rt1_recurrenceRule IS NOT NULL OR repeater IS NOT NULL) AS isTemplate " +
+                "FROM TMTask WHERE uuid = ?")
+                .get(firstUuid)
+            : undefined;
+        // The day D: a template's PROJECTION day (rt1_nextInstanceStartDate), else a
+        // scheduled row's startDate, else a forecast row's deadline (mirrors
+        // computeReorderPre so the when= legs and the member set agree on D).
         dayPacked =
-            firstUuid !== undefined
-                ? (deps.db.prepare("SELECT startDate FROM TMTask WHERE uuid = ?").get(firstUuid)?.startDate ?? null)
-                : null;
+            firstRow === undefined
+                ? null
+                : firstRow.isTemplate === 1
+                    ? firstRow.proj
+                    : firstRow.startDate !== null && firstRow.startBucket === 0
+                        ? firstRow.startDate
+                        : firstRow.startDate === null && (firstRow.start === 1 || firstRow.start === 2)
+                            ? firstRow.deadline
+                            : null;
         const iso = decodePackedDate(dayPacked);
         backValue = iso ?? localToday(now());
         awayValue = iso !== null ? addDaysIso(iso, 1) : localToday(now());
@@ -641,6 +676,21 @@ async function runBounce(deps, params, bounceKind, options) {
         awayValue = spec.away;
         backValue = spec.back;
     }
+    // A day-scope DEADLINE-FORECAST row (startDate NULL, deadline set) reorders by the
+    // DLBNC deadline-cycle (URL `deadline=` clear + re-set of the SAME deadline —
+    // byte-identical, front-inserts on the block's todayIndex axis) instead of the
+    // scheduled `when=` bounce. Returns the decoded ISO to re-set, or null for a
+    // scheduled row (which takes the `when=` legs). AppleScript `due date` is
+    // certified-wrong here (lazy todayIndex, cannot clear) — URL only (DLBNC §9q).
+    const forecastLegOf = (uuid) => {
+        if (bounceKind !== "day")
+            return null;
+        const r = deps.db.prepare("SELECT startDate, deadline FROM TMTask WHERE uuid = ?").get(uuid);
+        if (r === undefined || r.startDate !== null || r.deadline === null)
+            return null;
+        const iso = decodePackedDate(r.deadline);
+        return iso === null ? null : { iso };
+    };
     // Per-item leg op: the mixed-kind `day`/`evening` bounces pick update-project for
     // a project row (type=1) and todo.update for a to-do (type=0); every other bounce
     // uses one fixed op. (NEVER send a dated when= leg to a template — §1 crash — but
@@ -654,7 +704,7 @@ async function runBounce(deps, params, bounceKind, options) {
     };
     const txnId = `txn-${startedAt.getTime().toString(36)}-${process.pid.toString(36)}`;
     // Scope/membership guard — same data the native path's guard uses.
-    const pre = computeReorderPre(deps.db, params, containerUuid, now());
+    const pre = computeReorderPre(deps.db, params, containerUuid, now(), { zone: deps.zone });
     // Pre-ranks make the SUMMARY record the undoable unit (a single inverse
     // reorder restores the old relative order); legs are excluded from undo.
     const preRanks = {};
@@ -764,14 +814,82 @@ async function runBounce(deps, params, bounceKind, options) {
         });
         return result;
     }
+    // TMPLSORT/PTMPL template leg families (the `day` scope only — the native
+    // `tomorrow` one-call wire carries templates as ordinary members). A repeating
+    // template's projection is a first-class day-block member, but a dated when=/
+    // deadline leg CRASHES it (§1), so it NEVER receives one. Split per class:
+    //   - TO-DO template: a single-id `list "Upcoming"` NATIVE front-insert leg
+    //     (TMPLSORT-1), interleaved into the reverse-target dispatch on the shared
+    //     block min-space (TMPLSORT-2). Needs the native surface.
+    //   - PROJECT template: byte-UNTOUCHED under the SUFFIX RULE — it has no headless
+    //     reach on an arbitrary future day (PTMPL-B: only `list "Tomorrow"` / a GUI
+    //     drag place it), so every movable front-inserts ABOVE it. Accept only a wire
+    //     where the project templates form a suffix in their CURRENT relative order;
+    //     refuse otherwise, naming the one achievable arrangement.
+    // The whole day dispatch is experimental-gated when ANY template is present.
+    const memberInfo = new Map(pre.members.map((m) => [m.uuid, m]));
+    const isTmpl = (u) => memberInfo.get(u)?.isTemplate === true;
+    const isProjectTemplate = (u) => isTmpl(u) && memberInfo.get(u)?.type === 1;
+    const templatesPresent = bounceKind === "day" && coBounce.some(isTmpl);
+    let dispatchRun = coBounce;
+    if (templatesPresent) {
+        const dayIso = decodePackedDate(dayPacked) ?? "the target day";
+        const templateRefusal = (detail, remediation) => {
+            const result = {
+                kind: "blocked",
+                op: "reorder",
+                reason: "hazard",
+                hazard: "H-REORDER-SCOPE",
+                detail,
+                remediation,
+            };
+            auditSummary(deps, params, startedAt, "blocked:H-REORDER-SCOPE", null, {
+                pre: preRanks,
+                txnId,
+                actor,
+            });
+            return result;
+        };
+        if (!nativeReorderAvailable(deps)) {
+            // C(iii): refuse honestly, NAMING the templates — never a dated leg (crash),
+            // never a silent skip, never a partial sort.
+            const tmpls = coBounce.filter(isTmpl);
+            return templateRefusal(`the ${dayIso} day-group contains repeating template(s) [${tmpls.join(", ")}] whose ` +
+                "day-block placement needs the native private reorder surface (a dated when= leg CRASHES " +
+                `a template — §1/§9e), but it is unavailable (${nativeUnavailableReason(deps)})`, "enable it with `things config set allow-experimental true` (and keep Things updated so the " +
+                "sdef canary passes), or reorder the day-group without the template(s)");
+        }
+        // PROJECT-template SUFFIX RULE.
+        const projectTemplates = coBounce.filter(isProjectTemplate);
+        if (projectTemplates.length > 0) {
+            const suffix = coBounce.slice(coBounce.length - projectTemplates.length);
+            const suffixContiguous = suffix.every(isProjectTemplate);
+            // Their achievable order is their CURRENT todayIndex (render) order — untouched.
+            const currentOrder = projectTemplates.toSorted((a, b) => (memberInfo.get(a)?.rank ?? 0) - (memberInfo.get(b)?.rank ?? 0));
+            const orderPreserved = suffixContiguous && suffix.every((u, i) => u === currentOrder[i]);
+            if (!orderPreserved) {
+                const movables = coBounce.filter((u) => !isProjectTemplate(u));
+                const achievable = [...movables, ...currentOrder];
+                return templateRefusal(`a repeating PROJECT template cannot be placed above a movable item on the ${dayIso} ` +
+                    "day-block, and project templates cannot change their relative order there — an arbitrary " +
+                    "future day gives a project template no headless reach (PTMPL-B: only the Tomorrow one-call " +
+                    "sort, when the day is tomorrow, or a GUI drag place it). The only arrangement this " +
+                    `day-group can reach headlessly is: ${achievable.join(", ")} (every movable above the ` +
+                    "project template(s), which keep their current relative order)", "request that arrangement (place the project template(s) last, in their current order), or " +
+                    "drag the project template in the app; if the day is tomorrow, reorder on Tomorrow instead");
+            }
+        }
+        // Movables + to-do templates dispatch; project templates are the untouched suffix.
+        dispatchRun = coBounce.filter((u) => !isProjectTemplate(u));
+    }
     // Front-insert contexts (loose/area-direct) place last-first (reverse iterate,
     // unshift); back-insert contexts (heading/project children) place first-first
     // (forward iterate, push). Either way `placed` holds the current top-to-bottom
     // order of the bounced block. The SAME per-item order drives the json-array
     // collapse (array order == result index order for both directions).
     const order = direction === "front"
-        ? coBounce.map((_, i) => coBounce.length - 1 - i)
-        : coBounce.map((_, i) => i);
+        ? dispatchRun.map((_, i) => dispatchRun.length - 1 - i)
+        : dispatchRun.map((_, i) => i);
     // BOUNCEJSON collapse (§9i): when the placement (`back`) leg is when=anytime
     // into a loose/heading-container bucket, the whole N-item round-trip collapses
     // to ONE pre-validated `things:///json` array (2N ops, 1 dispatch, ~7×,
@@ -783,18 +901,39 @@ async function runBounce(deps, params, bounceKind, options) {
     const dispatchVector = spec.jsonCollapsible && legOp !== "per-type" ? pickDispatchVector(deps, legOp) : undefined;
     const useJson = spec.jsonCollapsible && dispatchVector !== undefined && dispatchVector.simulates !== true;
     if (options.dryRun === true) {
+        // Name the per-row-class legs. A `day` set may mix SCHEDULED rows (when= bounce)
+        // and DEADLINE-FORECAST rows (the DLBNC deadline-cycle: deadline= clear + re-set),
+        // so the plan discloses the leg family per class + count; every other bounce is a
+        // single when= round-trip.
+        let legNaming = `when=${awayValue} → when=${backValue}`;
+        if (bounceKind === "day") {
+            const ttN = coBounce.filter((u) => isTmpl(u) && !isProjectTemplate(u)).length;
+            const ptN = coBounce.filter(isProjectTemplate).length;
+            const fN = coBounce.filter((u) => !isTmpl(u) && forecastLegOf(u) !== null).length;
+            const sN = coBounce.length - fN - ttN - ptN;
+            const bits = [];
+            if (sN > 0)
+                bits.push(`${sN} scheduled via when=${awayValue} → when=${backValue}`);
+            if (fN > 0)
+                bits.push(`${fN} deadline-forecast via deadline-cycle (deadline= clear + re-set)`);
+            if (ttN > 0)
+                bits.push(`${ttN} to-do template(s) via single-id \`list "Upcoming"\` front-insert (umd-silent)`);
+            if (ptN > 0)
+                bits.push(`${ptN} project template(s) left byte-untouched (suffix rule — no headless reach)`);
+            legNaming = bits.join("; ");
+        }
         const invocation = useJson
             ? `json-collapse ×${coBounce.length} (${direction}-insert, ` +
                 `${direction === "front" ? "reverse" : "forward"} array order, ` +
                 (touchedUnnamed.length > 0 ? `touches ${touchedUnnamed.length} unnamed sibling(s), ` : "") +
                 `1 dispatch / ${coBounce.length * 2} ops): ` +
-                `when=${awayValue} → when=${backValue} interleaved per item; validate-first full-abort, ` +
+                `${legNaming} interleaved per item; validate-first full-abort, ` +
                 `one terminal order verify`
             : `bounce ×${coBounce.length} (${direction}-insert, ` +
                 `${direction === "front" ? "reverse" : "forward"} order, ` +
                 (touchedUnnamed.length > 0 ? `touches ${touchedUnnamed.length} unnamed sibling(s), ` : "") +
                 `${coBounce.length * 2} legs): ` +
-                `when=${awayValue} → when=${backValue}; one verify per item round-trip`;
+                `${legNaming}; one verify per item round-trip`;
         return {
             kind: "dry-run",
             op: "reorder",
@@ -826,8 +965,8 @@ async function runBounce(deps, params, bounceKind, options) {
     const placed = [];
     for (let step = 0; step < order.length; step++) {
         const i = order[step];
-        const uuid = coBounce[i];
-        const remainingBefore = () => direction === "front" ? coBounce.slice(0, i + 1) : coBounce.slice(i);
+        const uuid = dispatchRun[i];
+        const remainingBefore = () => direction === "front" ? dispatchRun.slice(0, i + 1) : dispatchRun.slice(i);
         // Concurrent-edit re-check: the item must still be an eligible member.
         const memberProblem = checkStillMember(deps, uuid, bounceKind, containerUuid, now(), dayPacked);
         if (memberProblem !== null) {
@@ -843,31 +982,91 @@ async function runBounce(deps, params, bounceKind, options) {
                 cause: null,
             };
         }
+        // A repeating TO-DO template rides ONE native single-id `list "Upcoming"` front-
+        // insert leg (TMPLSORT-1) — NEVER a dated when=/deadline leg (§1 crash). It front-
+        // inserts on the SAME shared block min-space as the when=/deadline families, so the
+        // reverse-target dispatch interleaves it exactly (TMPLSORT-2). Project templates are
+        // excluded from `dispatchRun` (the untouched suffix), so only to-do templates reach
+        // this branch; the leg is umd-silent (§9r — disclosed in the result note).
+        if (isTmpl(uuid)) {
+            const tmplLeg = await runMutation(deps, "reorder", { scope: "upcoming", uuids: [uuid], named: [uuid] }, legOptions(options, txnId));
+            if (tmplLeg.kind !== "ok") {
+                auditSummary(deps, params, startedAt, "verify-failed:mismatch", { placed: [...placed] }, { pre: preRanks, txnId, actor });
+                return {
+                    kind: "bounce-aborted",
+                    op: "reorder",
+                    detail: `the native \`list "Upcoming"\` front-insert leg failed for repeating template ${uuid} ` +
+                        "— it was NOT moved (its position is unchanged)",
+                    placed: [...placed],
+                    remaining: remainingBefore(),
+                    cause: tmplLeg,
+                };
+            }
+            if (direction === "front")
+                placed.unshift(uuid);
+            else
+                placed.push(uuid);
+            const tmplPrefix = await pollUntilVerified(() => evaluateDelta({ mode: "ordering", key: rankKey, sequence: [...placed] }, createDbReader(deps.db), { modDates: {}, fields: {} }), options.verifyTimeoutMs ?? 4000, deps.poller ?? {});
+            if (tmplPrefix.kind !== "ok") {
+                auditSummary(deps, params, startedAt, "verify-failed:mismatch", { placed: [...placed] }, { pre: preRanks, txnId, actor });
+                return {
+                    kind: "bounce-aborted",
+                    op: "reorder",
+                    detail: `placed items fell out of order after front-inserting template ${uuid} (concurrent ` +
+                        "edit?); re-run the reorder once Things is idle",
+                    placed: [...placed],
+                    remaining: direction === "front" ? dispatchRun.slice(0, i) : dispatchRun.slice(i + 1),
+                    cause: null,
+                };
+            }
+            continue;
+        }
         // leg 1 sends the item AWAY from its resting bucket; leg 2 returns it — the
-        // return leg is what front/back-inserts (BOUNCE2 re-entry law). The op is
-        // chosen per row type (to-do vs project) for the mixed-kind day/evening bounce.
+        // return leg is what front-inserts (BOUNCE2 re-entry law). SCHEDULED rows use
+        // the `when=` round-trip; a day-scope DEADLINE-FORECAST row (startDate NULL,
+        // deadline set) uses the DLBNC deadline-cycle instead: leg 1 CLEARS the deadline
+        // (transiently off the block), leg 2 RE-SETS the same deadline byte-identical
+        // (front-inserts on the block todayIndex axis). BOTH classes pick the leg op PER
+        // ROW TYPE — `todo.update` (→ `update?…`) for a to-do, `project.update` (→
+        // `update-project?…`) for a project — so a forecast PROJECT rides the #385-
+        // certified `update-project?deadline=` cycle (PROJDL-2b, PROJSTAR-safe). Both
+        // classes front-insert at the day's global min, so one reverse-target pass
+        // interleaves them exactly (o-suite forecast-cycle + mixed-interleave locks).
+        const forecast = forecastLegOf(uuid);
         const rowLegOp = opForRow(uuid);
-        const leg1 = await runMutation(deps, rowLegOp, { uuid, when: awayValue }, legOptions(options, txnId));
+        const awayLabel = forecast !== null ? "deadline= clear" : `when=${awayValue}`;
+        const backLabel = forecast !== null ? "deadline= re-set" : `when=${backValue}`;
+        const leg1 = forecast !== null
+            ? await runMutation(deps, rowLegOp, { uuid, deadline: null }, legOptions(options, txnId))
+            : await runMutation(deps, rowLegOp, { uuid, when: awayValue }, legOptions(options, txnId));
         if (leg1.kind !== "ok") {
             auditSummary(deps, params, startedAt, "verify-failed:mismatch", { placed: [...placed] }, { pre: preRanks, txnId, actor });
             return {
                 kind: "bounce-aborted",
                 op: "reorder",
-                detail: `bounce leg 1 (when=${awayValue}) failed for ${uuid} — the item was NOT moved`,
+                detail: `bounce leg 1 (${awayLabel}) failed for ${uuid} — the item was NOT moved`,
                 placed: [...placed],
                 remaining: remainingBefore(),
                 cause: leg1,
             };
         }
         // leg 2 must follow leg 1's committed state for the same item before the next item's bounce begins
-        const leg2 = await runMutation(deps, rowLegOp, { uuid, when: backValue }, legOptions(options, txnId));
+        const leg2 = forecast !== null
+            ? await runMutation(deps, rowLegOp, { uuid, deadline: forecast.iso }, legOptions(options, txnId))
+            : await runMutation(deps, rowLegOp, { uuid, when: backValue }, legOptions(options, txnId));
         if (leg2.kind !== "ok") {
             auditSummary(deps, params, startedAt, "verify-failed:mismatch", { placed: [...placed] }, { pre: preRanks, txnId, actor });
+            const strandedState = forecast !== null
+                ? "left DEADLINE-LESS (transiently off the day-block)"
+                : `STRANDED IN ${String(awayValue).toUpperCase()}`;
+            const recover = forecast !== null
+                ? `re-set its deadline (${forecast.iso})`
+                : `re-schedule it (when=${backValue})`;
             return {
                 kind: "bounce-aborted",
                 op: "reorder",
-                detail: `bounce leg 2 (when=${backValue}) failed for ${uuid} — THE ITEM IS STRANDED IN ` +
-                    `${String(awayValue).toUpperCase()}; re-schedule it (when=${backValue}) or fix in the app`,
+                detail: `bounce leg 2 (${backLabel}) failed for ${uuid} — THE ITEM IS ${strandedState}; ` +
+                    `${recover} or fix in the app`,
                 placed: [...placed],
                 remaining: remainingBefore(),
                 cause: leg2,
@@ -889,7 +1088,7 @@ async function runBounce(deps, params, bounceKind, options) {
                 detail: `placed items fell out of order after bouncing ${uuid} (concurrent edit?); ` +
                     "re-run the reorder once Things is idle",
                 placed: [...placed],
-                remaining: direction === "front" ? coBounce.slice(0, i) : coBounce.slice(i + 1),
+                remaining: direction === "front" ? dispatchRun.slice(0, i) : dispatchRun.slice(i + 1),
                 cause: null,
             };
         }
@@ -899,6 +1098,25 @@ async function runBounce(deps, params, bounceKind, options) {
     for (const uuid of coBounce)
         observed[uuid] = reader.rankOf(uuid, rankKey);
     auditSummary(deps, params, startedAt, "ok", observed, { pre: preRanks, txnId, actor });
+    // §9r disclosure: a template's `list "Upcoming"` front-insert leg is
+    // userModificationDate-SILENT (a umd-diffing sync/watcher misses it), and a project
+    // template left as the untouched suffix moved not at all — surface both so the caller
+    // never mistakes a umd-silent placement for a no-op.
+    const warnings = [];
+    if (templatesPresent) {
+        const tt = coBounce.filter((u) => isTmpl(u) && !isProjectTemplate(u));
+        const pt = coBounce.filter(isProjectTemplate);
+        if (tt.length > 0) {
+            warnings.push(`${tt.length} repeating to-do template(s) were front-inserted via \`list "Upcoming"\` and ` +
+                "are userModificationDate-SILENT (a umd-diffing sync/watcher will not see the move): " +
+                tt.join(", "));
+        }
+        if (pt.length > 0) {
+            warnings.push(`${pt.length} repeating project template(s) were left byte-untouched as the day-block suffix ` +
+                "(no headless reach on this day — every movable was placed above them): " +
+                pt.join(", "));
+        }
+    }
     return {
         kind: "ok",
         op: "reorder",
@@ -909,6 +1127,7 @@ async function runBounce(deps, params, bounceKind, options) {
         // A bounce reorder is a summary txn, so its token is the txn id (matches
         // the audit record's undoToken); pass it to `things undo --txn <token>`.
         undoToken: txnId,
+        ...(warnings.length > 0 && { warnings }),
         // Co-bounced siblings the anchor placement re-inserted (honest disclosure).
         ...(touchedUnnamed.length > 0 && { touched: touchedUnnamed }),
     };
@@ -1398,7 +1617,7 @@ async function runMoveFallback(deps, params, fallback, options) {
     const cap = deps.config.bounceMaxItems ?? BOUNCE_MAX_ITEMS;
     const containerUuid = resolveContainerUuid(deps, params);
     const txnId = `txn-${startedAt.getTime().toString(36)}-${process.pid.toString(36)}`;
-    const pre = computeReorderPre(deps.db, params, containerUuid, now());
+    const pre = computeReorderPre(deps.db, params, containerUuid, now(), { zone: deps.zone });
     // proj-root BACK-inserts (forward dispatch → suffix from the first named slot);
     // inbox/area FRONT-insert (reverse dispatch → prefix to the last named slot).
     const direction = fallback === "proj-root" ? "back" : "front";
@@ -1969,7 +2188,8 @@ function resolveContainerUuid(deps, params) {
 function checkStillMember(deps, uuid, bounceKind, containerUuid, now, dayPacked) {
     const packedToday = encodePackedDate(localToday(now));
     const row = deps.db
-        .prepare("SELECT status, trashed, startBucket, startDate, start, type, area, project, heading " +
+        .prepare("SELECT status, trashed, startBucket, startDate, start, type, area, project, heading, deadline, " +
+        "rt1_recurrenceRule AS rule, repeater, rt1_nextInstanceStartDate AS proj " +
         "FROM TMTask WHERE uuid = ?")
         .get(uuid);
     if (row === undefined)
@@ -2052,14 +2272,28 @@ function checkStillMember(deps, uuid, bounceKind, containerUuid, now, dayPacked)
             return null;
         }
         case "day": {
-            // The dated bounce's members are to-dos (any container) and scheduled project
-            // rows (area-less OR area-direct — SIT5 AREAPROJDAY) sharing the day D on the
-            // startBucket=0 axis. A concurrent edit that re-dates, de-schedules, or
-            // evenings the row ejects it from the group.
+            // The dated bounce's members are SCHEDULED to-dos (any container) and scheduled
+            // project rows (area-less OR area-direct — SIT5 AREAPROJDAY) sharing the day D
+            // on the startBucket=0 axis, PLUS DEADLINE-FORECAST to-dos (startDate NULL,
+            // start IN (1,2), deadline == D — DLBNC/§9o) on the SAME block todayIndex axis.
+            // A concurrent edit that re-dates, de-schedules, evenings, clears the deadline,
+            // or drops the row to the Inbox (start=0) ejects it from the group.
             if (row.type !== 0 && row.type !== 1)
                 return "the item is not a to-do or project";
-            if (row.startBucket !== 0 || row.startDate !== dayPacked) {
-                return "the item left the day-group (re-dated, evening-ed, or de-scheduled)";
+            // A repeating TEMPLATE stays a day-block member via its PROJECTION day
+            // (rt1_nextInstanceStartDate — TMPLSORT/PTMPL), not startDate/deadline.
+            if (row.rule !== null || row.repeater !== null) {
+                return row.proj === dayPacked
+                    ? null
+                    : "the template's projection day changed (its recurrence rule was edited)";
+            }
+            const scheduled = row.startBucket === 0 && row.startDate !== null && row.startDate === dayPacked;
+            const forecast = row.startDate === null &&
+                (row.start === 1 || row.start === 2) &&
+                row.deadline !== null &&
+                row.deadline === dayPacked;
+            if (!scheduled && !forecast) {
+                return "the item left the day-group (re-dated, evening-ed, de-scheduled, or its deadline changed)";
             }
             return null;
         }