things-api 0.12.0 → 0.14.0

package/dist/write/move.js

@@ -2,19 +2,21 @@ import { addDaysIso, decodePackedDate, encodePackedDate, localToday } from "../m
 import { ReferenceResolutionError, resolveTaskUuidPrefix } from "../read/queries.js";
 import { taskMembershipClause } from "../read/scope.js";
 import { isLooseRef, LOOSE_TO_AREA_REFUSAL } from "../read/pseudo-area.js";
-import { computeReorderPre, resolveArea, resolveHeading, resolveProject } from "./pre-state.js";
+import { computeHeadingMovePre, computeReorderPre, resolveArea, resolveHeading, resolveProject, } from "./pre-state.js";
 import {} from "./pipeline.js";
 import { runMutation } from "./pipeline.js";
 import { runReorder } from "./reorder.js";
 function loadRow(db, uuid) {
     const row = db
-        .prepare("SELECT uuid, title, type, project, area, heading, start, startDate, startBucket, " +
-        "rt1_recurrenceRule AS rule, repeater FROM TMTask WHERE uuid = ?")
+        .prepare("SELECT uuid, title, type, project, area, heading, start, startDate, startBucket, deadline, " +
+        "rt1_recurrenceRule AS rule, repeater, rt1_nextInstanceStartDate AS projectionDay " +
+        "FROM TMTask WHERE uuid = ?")
         .get(uuid);
     if (row === undefined)
         return undefined;
-    const { rule, repeater, ...rest } = row;
-    return { ...rest, isTemplate: rule !== null || repeater !== null };
+    const { rule, repeater, projectionDay, ...rest } = row;
+    const isTemplate = rule !== null || repeater !== null;
+    return { ...rest, isTemplate, templateProjectionDay: isTemplate ? projectionDay : null };
 }
 const KIND_LABEL = { 0: "to-do", 1: "project", 2: "heading" };
 /**
@@ -58,6 +60,33 @@ function scheduleBucket(row, packedToday) {
         return "someday";
     return "anytime";
 }
+/**
+ * The packed future-deadline day of a DEADLINE-FORECAST row (DLBNC / #383, #385),
+ * or null. The §9o forecast cohort: a to-do (type=0) OR project (type=1) with NO
+ * `startDate`, someday/anytime stage (`start IN (1,2)`), and a strictly-FUTURE
+ * `deadline` rests on that deadline day's ROOT Upcoming day-block on the shared
+ * `todayIndex` axis (UPCDL-1a/§9o, GUI-confirmed DLBNC-1d; forecast PROJECTS carry
+ * the axis identically — PROJDL-2a/2b/2c, #385). It reorders there via the deadline-
+ * cycle (URL `deadline=` clear + re-set — `update` for a to-do, `update-project`
+ * for a project), NOT the someday/anytime `index` lever — so the planner routes it
+ * to the `day` scope keyed on the deadline. INBOX-stage rows (`start=0`) rest OFF
+ * the axis (todayIndex=0) — excluded here; a today/past deadline is NOT a future
+ * day-block (the row renders in its someday/anytime bucket with an overdue badge) —
+ * excluded, matching the strictly-future gate scheduled rows use. Headings (type=2)
+ * are excluded. PROJSTAR-safe: the project deadline-cycle never flips `start` to 1
+ * (no accidental Today star) and preserves `index`/area-FK/tags (PROJDL-2b/2b').
+ */
+function forecastDeadlineDay(row, packedToday) {
+    if (row.type !== 0 && row.type !== 1)
+        return null;
+    if (row.startDate !== null)
+        return null;
+    if (row.start !== 1 && row.start !== 2)
+        return null;
+    if (row.deadline === null || row.deadline <= packedToday)
+        return null;
+    return row.deadline;
+}
 /** An app-default target for a bounce-dependent placement while bounce is off. */
 function bounceDisabledTarget(what) {
     return {
@@ -90,7 +119,24 @@ function bounceDisabledTarget(what) {
  */
 function reorderTargetOf(row, isTodo, packedToday, bounceEnabled) {
     if (row.isTemplate) {
-        return { scope: null, reason: "a repeating template (unreorderable — oddity §9e)" };
+        // A repeating template's Upcoming-day-block projection is a first-class todayIndex
+        // member of its projection day (TMPLSORT/PTMPL): route it to the day-group scope so
+        // it rides the template-aware leg family in reorder.ts — the native one-call `list
+        // "Tomorrow"` wire when the projection == tomorrow (both to-do AND project
+        // templates: TMPLSORT-3c-Tomorrow / PTMPL-B5), else the `day` scope (a TO-DO
+        // template front-inserts via a single-id `list "Upcoming"` leg; a PROJECT template
+        // is byte-untouched under the suffix rule). A template with no strictly-future
+        // projection has no wired day-block surface — app-default, honest.
+        const day = rowDayKey(row, packedToday);
+        if (day === null) {
+            return {
+                scope: null,
+                reason: "a repeating template with no strictly-future projection (§9e)",
+            };
+        }
+        return day === packedTomorrowOf(packedToday)
+            ? { scope: "tomorrow", day }
+            : { scope: "day", day };
     }
     const bucket = scheduleBucket(row, packedToday);
     // A same-day (today-proper) or future scheduled day, startBucket=0 — the
@@ -114,6 +160,17 @@ function reorderTargetOf(row, isTodo, packedToday, bounceEnabled) {
     // so they take the dated bounce even on tomorrow.
     const isTomorrow = row.startBucket === 0 && row.startDate === packedTomorrowOf(packedToday);
     if (isTodo) {
+        // DEADLINE-FORECAST members route FIRST (DLBNC / #383). A someday/anytime-stage
+        // to-do (no startDate) with a future deadline is a first-class member of that
+        // deadline day's Upcoming block — it reorders on the block's todayIndex axis via
+        // the deadline-cycle (URL deadline= clear + re-set), never the someday/anytime
+        // index lever. ALWAYS the `day` scope keyed on the deadline — NEVER the native
+        // `list "Tomorrow"` sort even when the deadline is tomorrow, because that surface
+        // RE-DATES a forecast row (stamps a startDate, UPCDL-5), ejecting it from the
+        // forecast cohort. The deadline-cycle is public-URL-only (no experimental gate).
+        const fDay = forecastDeadlineDay(row, packedToday);
+        if (fDay !== null)
+            return { scope: "day", day: fDay };
         // ARRIVED Today-view members route DATE-FIRST, before any container branch.
         // A dated row whose day has landed (startDate <= today) is a Today member —
         // the GUI renders arrived/today-dated rows in the TODAY view; the Upcoming
@@ -262,6 +319,20 @@ function indexAxisTargetOf(row, bounceEnabled) {
     // shared loose index bucket and spuriously "dual-axis ambiguous".
     return reorderTargetOf(asAnytime, row.type === 0, 0, bounceEnabled);
 }
+/**
+ * The INDEX-axis reorder target of a DEADLINE-FORECAST row (§9o dual-citizen) —
+ * its container's someday/anytime `index` order, the alternative to its Upcoming
+ * day-block todayIndex axis. Classified by STRIPPING the deadline so
+ * reorderTargetOf routes to the container index (someday/anytime/project/area/
+ * heading-someday), never the `day` scope the forecast day-block routes to. Used
+ * both to name the container spelling in the dual-axis refusal and to classify a
+ * forecast row that an explicit `--in <container>` / `--in someday|anytime` forces
+ * onto its index axis (the bug-fix: `--in` must never be overridden by the day
+ * auto-route).
+ */
+function forecastIndexTargetOf(row, packedToday, bounceEnabled) {
+    return reorderTargetOf({ ...row, deadline: null }, row.type === 0, packedToday, bounceEnabled);
+}
 /**
  * True when a row's INDEX-axis target preserves the Today/Evening flag. TWO
  * flag-safe families:
@@ -311,11 +382,38 @@ function describeSetLocation(rows, packedToday) {
     const buckets = [...new Set(rows.map((r) => scheduleBucket(r, packedToday)))];
     return `in the ${buckets.join(" / ")} bucket`;
 }
-/** Parse a raw `--in <target>` into a list axis or a resolved container ref. */
+/** The DIRECT container a row sits in, named for a refusal (its title, or "the loose list"). */
+function describeDirectContainer(deps, row) {
+    const c = indexAxisContainerOf(row);
+    return c === null ? "the loose list" : `"${containerLabel(deps, c)}"`;
+}
+/** Per-movee day membership (`uuid on YYYY-MM-DD`, or off-day), for the `--in upcoming` spread refusal. */
+function describeDayMembership(rows, packedToday) {
+    return rows
+        .map((r) => {
+        const k = rowDayKey(r, packedToday);
+        return k === null ? `${r.uuid} (not on a future day)` : `${r.uuid} on ${decodePackedDate(k)}`;
+    })
+        .join("; ");
+}
+/** Parse a raw `--in <target>` into a list axis, a day-axis token, or a container ref. */
 function parseInTarget(deps, raw, rows) {
     const norm = raw.trim().toLowerCase();
     if (IN_AXES.includes(norm))
         return { axis: norm };
+    // Day-axis tokens (checked before container resolution so an ISO date is never
+    // read as a container title). `upcoming` is the shared-future-day proxy; a
+    // YYYY-MM-DD names one exact Upcoming day-block.
+    if (norm === "upcoming")
+        return { upcoming: true };
+    if (/^\d{4}-\d{2}-\d{2}$/.test(norm)) {
+        try {
+            return { day: encodePackedDate(norm) };
+        }
+        catch {
+            return { error: `--in "${raw}" is not a valid calendar date (expected YYYY-MM-DD)` };
+        }
+    }
     if (norm === "loose") {
         return {
             error: '`--in loose` is not valid — "loose" is a read view, not a reorder bucket; ' +
@@ -345,7 +443,7 @@ function parseInTarget(deps, raw, rows) {
     }
     return {
         error: `--in "${raw}" did not resolve to a project, area, or heading ` +
-            "(or one of today | evening | anytime | someday | inbox)",
+            "(or one of today | evening | anytime | someday | inbox | upcoming | a YYYY-MM-DD day)",
     };
 }
 /**
@@ -375,20 +473,76 @@ function resolveReorderAxis(deps, op, rows, inTarget, packedToday, verb, positio
     // single-bucket guard; view=null means "not a clean view set".)
     const views = new Set(coherence.map((r) => viewOf(r, packedToday)));
     const view = views.size === 1 ? [...views][0] : null;
+    // An INDEX bucket sorts each object KIND in its OWN rank space (an area's someday
+    // to-dos and someday projects are DIFFERENT index buckets — spec axis-isolation),
+    // so a MIXED to-do+project movee set has NO shared container index: only its
+    // GLOBAL axis (the Today/Evening view or the Upcoming day-block, both of which
+    // intermix kinds) is coherent. Nulling the index target for a cross-kind set keeps
+    // the dual-axis refusals (view + forecast) and the mixed auto-route from treating
+    // it as container-sortable; it falls through to its global axis instead. (A wrong-
+    // kind movee that ISN'T bound for a global axis was already refused upstream in
+    // runInPlaceReorder, so the only cross-kind sets that reach here are global ones.)
+    const sameKind = new Set(rows.map((r) => r.type)).size === 1;
     // The shared index-axis container target, if the whole coherence set has one
     // (classifying each row as though it sat in its container's anytime bucket).
     const indexTargets = coherence.map((r) => indexAxisTargetOf(r, bounceEnabled));
     const indexKeys = new Set(indexTargets.map(containerKey));
-    const indexTarget = indexKeys.size === 1 && indexTargets[0]?.scope != null
+    const indexTarget = sameKind && indexKeys.size === 1 && indexTargets[0]?.scope != null
         ? indexTargets[0]
         : null;
-    // Force the CONTAINER index axis for view members, leaving non-view members on
-    // their natural target (used when --in names a container).
-    const indexClassifier = (r) => viewOf(r, packedToday) !== null ? indexAxisTargetOf(r, bounceEnabled) : base(r);
+    // Force the CONTAINER index axis for a dual-axis row, leaving single-axis rows on
+    // their natural target (used when --in names a container or a loose stage list).
+    // A Today/Evening member forces onto its container index (view axis stripped); a
+    // DEADLINE-FORECAST row forces onto its someday/anytime container index (day-block
+    // axis stripped, §9o) — without this a forecast row would classify to the `day`
+    // scope and the explicit `--in` would be overridden by the day route.
+    const indexClassifier = (r) => {
+        if (viewOf(r, packedToday) !== null)
+            return indexAxisTargetOf(r, bounceEnabled);
+        if (forecastDeadlineDay(r, packedToday) !== null)
+            return forecastIndexTargetOf(r, packedToday, bounceEnabled);
+        return base(r);
+    };
     if (inTarget !== undefined) {
         const parsed = parseInTarget(deps, inTarget, rows);
         if ("error" in parsed)
             return { refused: refused(op, "usage", parsed.error) };
+        // `--in <YYYY-MM-DD>` — one exact Upcoming day-block (the day axis). The date
+        // must be strictly future, and every movee must be a member of that day
+        // (scheduled startDate == date, or a forecast deadline == date per §9o). No
+        // shared-container requirement — a day-block is ONE cross-container axis.
+        if ("day" in parsed) {
+            const day = parsed.day;
+            if (day <= packedToday) {
+                return {
+                    refused: refused(op, "usage", `--in ${decodePackedDate(day)} is not a future day — that date is today or in the past; ` +
+                        "use --in today to reorder the Today view", "name a strictly-future YYYY-MM-DD day, or --in today for the Today view"),
+                };
+            }
+            const notMembers = rows.filter((r) => rowDayKey(r, packedToday) !== day);
+            if (notMembers.length > 0) {
+                return {
+                    refused: refused(op, "usage", `--in ${decodePackedDate(day)} but these items are not on that day: ` +
+                        notMembers.map((r) => r.uuid).join(", ") +
+                        " — a movee must be scheduled for it, or carry it as a deadline", "name the day the items actually share, or omit --in if they share one"),
+                };
+            }
+            return { dayAxis: day };
+        }
+        // `--in upcoming` — the single future day the whole set shares (the day axis),
+        // derived via sharedFutureDay. Stage-agnostic across scheduled + forecast, no
+        // container requirement; a set spanning days (or with an off-day member) refuses
+        // with the per-item days listed.
+        if ("upcoming" in parsed) {
+            const day = sharedFutureDay(rows, packedToday);
+            if (day === null) {
+                return {
+                    refused: refused(op, "blocked", "--in upcoming needs every item on ONE shared future day, but they are not: " +
+                        describeDayMembership(rows, packedToday), "name the exact day with --in YYYY-MM-DD, or reorder one day at a time"),
+                };
+            }
+            return { dayAxis: day };
+        }
         if ("axis" in parsed) {
             const axis = parsed.axis;
             if (axis === "today" || axis === "evening") {
@@ -421,19 +575,34 @@ function resolveReorderAxis(deps, op, rows, inTarget, packedToday, verb, positio
                             : ""), `reorder them in the view with --in ${view}, or reschedule them off Today first`),
                 };
             }
-            const wrong = rows.filter((r) => scheduleBucket(r, packedToday) !== axis ||
-                r.project !== null ||
-                r.area !== null ||
-                r.heading !== null);
-            if (wrong.length > 0) {
+            // Sanity + membership (spec rule 4). Every movee must BE that stage; and for
+            // anytime/someday every movee must share ONE direct container (same project,
+            // heading, area, or all loose — the index bucket they re-rank in). inbox needs
+            // only the stage check (inbox items are container-less by nature).
+            const wrongStage = rows.filter((r) => scheduleBucket(r, packedToday) !== axis);
+            if (wrongStage.length > 0) {
                 return {
-                    refused: refused(op, "usage", `--in ${axis} but the items are ${describeSetLocation(rows, packedToday)}` +
-                        (rows.some((r) => r.project !== null || r.area !== null || r.heading !== null)
-                            ? " (and some are in a container, not loose)"
-                            : ""), "omit --in and reorder the items where they are, or move them first"),
+                    refused: refused(op, "usage", `--in ${axis} but not every item is ${axis}-stage — ` +
+                        `${describeSetLocation(wrongStage, packedToday)}: ` +
+                        wrongStage.map((r) => r.uuid).join(", "), "omit --in and reorder the items where they are, or reschedule them first"),
                 };
             }
-            return { targetOf: base };
+            if (axis !== "inbox") {
+                const containers = new Set(rows.map((r) => structuralKey(r, packedToday)));
+                if (containers.size > 1) {
+                    return {
+                        refused: refused(op, "usage", `--in ${axis} but the items are in different containers (` +
+                            rows.map((r) => `${r.uuid} in ${describeDirectContainer(deps, r)}`).join("; ") +
+                            `) — a single --in ${axis} reorder needs them all in one project, heading, or ` +
+                            "area, or all loose", "reorder within one container at a time, or move them together first"),
+                    };
+                }
+            }
+            // The stage list axis is an INDEX axis — it suppresses the day auto-route so a
+            // forecast someday/anytime row re-ranks its container index here (the bug-fix:
+            // `--in someday` on a same-day forecast set compiles the index re-rank, not the
+            // deadline day bounce); indexClassifier strips the deadline for that.
+            return { targetOf: indexClassifier, indexAxis: true };
         }
         // A container ref (project/area/heading).
         const container = parsed.container;
@@ -472,6 +641,32 @@ function resolveReorderAxis(deps, op, rows, inTarget, packedToday, verb, positio
                 "(todayIndex slots) and the container (index slots); say which with --in", `--in ${view} to reorder the ${view} view, or ${inSpellingFor(deps, indexTarget)} to reorder within the container`),
         };
     }
+    // A FORECAST set coherent on BOTH axes (§9o dual-citizen): every movee a deadline-
+    // forecast member of ONE shared day AND all sharing one container index bucket.
+    // Ambiguous between the day-block (todayIndex) and the container (index) — refuse,
+    // echoing the REAL date and the container/list spelling. Forecast rows are never
+    // Today/Evening members, so this is the forecast twin of the view-member refusal
+    // above. (A forecast set spanning containers, or mixed with scheduled rows, is
+    // coherent on only the day axis → it auto-routes to `day` below, no refusal.)
+    const forecastDay = sharedForecastDay(rows, packedToday);
+    if (rows.length >= 2 && view === null && forecastDay !== null) {
+        const fTargets = rows.map((r) => forecastIndexTargetOf(r, packedToday, bounceEnabled));
+        const fKeys = new Set(fTargets.map(containerKey));
+        // A cross-kind forecast set has no shared container index (kinds isolate), so it
+        // is coherent on ONLY the day-block axis — not dual-axis. Auto-route it there
+        // (below) rather than offering a container spelling that would then kind-refuse.
+        const fIndexTarget = sameKind && fKeys.size === 1 && fTargets[0]?.scope != null
+            ? fTargets[0]
+            : null;
+        if (fIndexTarget !== null) {
+            const date = decodePackedDate(forecastDay);
+            return {
+                refused: refused(op, "blocked", `these items are forecast members of the ${date} Upcoming day-block that also share ` +
+                    `${describeScope(fIndexTarget)} — the reorder is ambiguous between the day-block ` +
+                    "(todayIndex slots) and the container (index slots); say which with --in", `--in ${date} to reorder the day-block, or ${inSpellingFor(deps, fIndexTarget)} to reorder within the container`),
+            };
+        }
+    }
     // A MIXED dual-axis set (some Today/Evening-flagged, some plain, all sharing one
     // flag-safe container index) is NOT ambiguous: the plain members are not view
     // members, so there is no shared view to reorder them in — the container index is
@@ -529,6 +724,37 @@ function refused(op, refusal, detail, remediation) {
         ...(remediation !== undefined && { remediation }),
     };
 }
+/**
+ * Map a non-ok reorder PLACEMENT from a pure in-place reposition (no membership
+ * leg ran, so NOTHING landed) to a terminal MoveResult. A `blocked` placement is
+ * a genuine refusal — the reorder never touched the app (an H-REORDER-SCOPE
+ * template suffix / experimental-off block) — so it HOISTS to a canonical
+ * top-level `move-refused` carrying the hazard: exit 4 (Blocked) + the
+ * `blocked:<hazard>` code + `BLOCKED (<hazard>)` copy, the SAME surface a direct
+ * `things reorder` block gets, instead of being buried under a generic
+ * leg-failed with a verify-failed (exit 3) code. Every other non-ok kind (a
+ * mid-bounce `bounce-aborted`, a `verify-failed`) is a leg that DID run and did
+ * not complete, so it stays `move-leg-failed`.
+ */
+function repositionFailed(op, placement) {
+    if (placement.kind === "blocked") {
+        return {
+            kind: "move-refused",
+            op,
+            refusal: "blocked",
+            detail: placement.detail,
+            ...(placement.remediation !== undefined && { remediation: placement.remediation }),
+            ...(placement.hazard !== undefined && { hazard: placement.hazard }),
+        };
+    }
+    return {
+        kind: "move-leg-failed",
+        op,
+        detail: `the reorder leg did not complete (${placement.kind})`,
+        failed: placement,
+        completed: [],
+    };
+}
 // The ratified teaching errors (spec §4 bare-invocation block, §5, §7).
 const BARE_TODO_MOVE = "`todo move` needs a destination or a position. To change what a to-do belongs to, name " +
     "one of --to-project / --to-heading / --to-area (or --no-heading / --loose to detach). To " +
@@ -905,6 +1131,36 @@ export async function runProjectMove(deps, request, options = {}) {
  * a contiguous block at the EARLIEST movee's current slot, in argument order
  * (spec §4 — `--first` is NOT implied). Cross-container operands fail closed.
  */
+/**
+ * The single-KIND refusal for an INDEX-axis reorder (a stage list, or a project/
+ * area/heading container `index`). An index bucket sorts each object KIND in its
+ * OWN rank space, so a to-do+project mix cannot re-rank in one call — even when the
+ * kinds share a container. A HEADING is never an index/day/view member at all: its
+ * order is the project's heading axis. The GLOBAL day/Today/Evening axes intermix
+ * kinds and never reach here. Copy is tailored per case, naming each movee's kind.
+ */
+function indexKindRefusal(op, rows) {
+    const headings = rows.filter((r) => r.type === 2);
+    if (headings.length > 0) {
+        return refused(op, "usage", "a heading has no stage, schedule, or day order of its own — it is never a Today/Evening, " +
+            "day-block, or stage-list member; a heading's order is the project's heading axis, not a " +
+            `to-do/project index bucket: ${headings.map((r) => r.uuid).join(", ")}`, "reorder a project's headings with `things project move-heading <project> <headings…>`");
+    }
+    const want = op === "todo.move" ? 0 : 1;
+    const named = rows.map((r) => `${r.uuid} (${KIND_LABEL[r.type] ?? "item"})`).join(", ");
+    // A homogeneous set of the OTHER kind (e.g. all projects handed to `todo reorder`):
+    // point at that kind's own reorder verb rather than the mixed-axis message.
+    if (rows.every((r) => r.type !== want)) {
+        return refused(op, "usage", `\`reorder\` on this path rearranges ${want === 0 ? "to-dos" : "projects"}, but every item ` +
+            `is a ${want === 0 ? "project" : "to-do"}: ${named}`, want === 0
+            ? "to rearrange projects use `things project move <refs…> --first/--last/--before/--after`"
+            : "to rearrange to-dos use `things todo reorder <refs…>`");
+    }
+    // A genuine to-do + project mix bound for an index bucket.
+    return refused(op, "usage", "one kind at a time — an index bucket sorts to-dos and projects in separate order-spaces (a " +
+        `shared container does not merge them), so a mixed set cannot re-rank in one call: ${named}`, "reorder the to-dos and the projects in separate calls; only the Today/Evening and day-block " +
+        "axes (--in today | evening | upcoming | a YYYY-MM-DD day) sort both kinds together");
+}
 export async function runInPlaceReorder(deps, op, request, options = {}) {
     const now = deps.now?.() ?? new Date();
     const packedToday = encodePackedDate(localToday(now));
@@ -933,61 +1189,446 @@ export async function runInPlaceReorder(deps, op, request, options = {}) {
             wrongKind.push({ ref: r.uuid, kind: KIND_LABEL[row.type] ?? "item" });
         rows.push(row);
     }
-    // The GLOBAL todayIndex buckets accept PROJECT rows INTERMIXED with to-dos in one
-    // reorder: `today` (O12 — `list "Today"` takes projects inline), `evening` (SIT4
-    // EVEORD — projects share the evening axis, per-type bounce legs), and the future
-    // day-group scopes (`day`/`tomorrow` — SIT4 DAYBNC + TOMORROWLIST accept area-
-    // less project rows). So on the `todo reorder` path a project movee is legal WHEN
-    // every movee sits in a today/evening/scheduled bucket; the mixed set routes to
-    // one of those scopes (whose wire list is type IN (0,1)). Every OTHER bucket
-    // keeps the homogeneous-kinds refusal, and an ineligible member still fails the
-    // downstream scope guard, so the relaxation never reaches an unvalidated scope.
+    // Kind rule (spec: index-axis isolation). The GLOBAL todayIndex axes INTERMIX
+    // object kinds in one reorder: `today` (O12 — `list "Today"` takes projects
+    // inline), `evening` (SIT4 EVEORD — projects share the evening axis, per-type
+    // bounce legs), and the future day-group scopes (`day`/`tomorrow`/`upcoming`/an
+    // `<ISO>` day — SIT4 DAYBNC + TOMORROWLIST accept area-less project rows; DEADLINE-
+    // FORECAST projects join that block via the update-project deadline-cycle, PROJDL-
+    // 2a/2c #385). An INDEX axis (a stage list `anytime`/`someday`/`inbox`, or a
+    // project/area/heading container `index`) sorts each KIND in its OWN rank space, so
+    // it takes ONE kind only — an area's someday to-dos and someday projects are
+    // DIFFERENT index buckets, so a shared container does not merge them.
+    //
+    // A movee kind mismatched to the reorder verb (a project/heading on `todo reorder`)
+    // is therefore legal ONLY when the whole set lands on a GLOBAL axis. It lands there
+    // when NO `--in` forces an index axis AND every movee is a today/evening/scheduled/
+    // forecast member (the bare set then auto-routes to a day/today scope whose wire
+    // list is type IN (0,1)). An explicit `--in anytime|someday|inbox|<container>`
+    // forces the index axis regardless of bucket, so it NEVER intermixes — this is what
+    // closes the #387-opened trap where a same-day forecast set's index token slipped
+    // the bucket-only relaxation.
+    const inNorm = request.in?.trim().toLowerCase();
+    const inForcesIndex = inNorm !== undefined &&
+        inNorm !== "today" &&
+        inNorm !== "evening" &&
+        inNorm !== "upcoming" &&
+        !/^\d{4}-\d{2}-\d{2}$/.test(inNorm);
     const globalAxisIntermix = isTodo &&
         rows.length > 0 &&
+        !inForcesIndex &&
         rows.every((r) => {
             const b = scheduleBucket(r, packedToday);
-            return b === "today" || b === "evening" || b.startsWith("scheduled:");
+            return (b === "today" ||
+                b === "evening" ||
+                b.startsWith("scheduled:") ||
+                forecastDeadlineDay(r, packedToday) !== null ||
+                // A repeating TEMPLATE with a strictly-future projection is a first-class
+                // day-block todayIndex member too (mirrors rowDayKey's template branch,
+                // #393). Its startDate is NULL and it carries no deadline, so it satisfies
+                // NEITHER branch above — without this disjunct a MIXED-kind day set that
+                // also holds a template fails `.every()`, `globalAxisIntermix` goes false,
+                // and the upstream indexKindRefusal blocks the set before the day-axis
+                // resolver (which #393 taught to admit templates) ever runs. That is Mike's
+                // "both kinds + template, one op" interleave, so the template must count as
+                // a day-group member here exactly as it does downstream.
+                (r.isTemplate && r.templateProjectionDay !== null && r.templateProjectionDay > packedToday));
         });
     if (wrongKind.length > 0 && !globalAxisIntermix) {
-        const list = wrongKind.map((w) => `${w.ref} (${w.kind})`).join(", ");
-        const allProjects = isTodo && rows.length > 0 && rows.every((r) => r.type === 1);
-        return refused(op, "usage", `homogeneous kinds required — \`reorder\` rearranges to-dos ` +
-            "(the Today, This Evening, and future day-group lists also accept project rows " +
-            `intermixed with to-dos); not: ${list}`, allProjects
-            ? "to rearrange projects in their sidebar/area/someday order use `things project move " +
-                "<refs…> --first/--last/--before/--after`"
-            : undefined);
+        return indexKindRefusal(op, rows);
     }
     return repositionInPlace(deps, op, rows, request.position, packedToday, options, "reorder", request.in);
 }
+/**
+ * The ONE reorder verb (`things reorder <refs…>`) — kind-aware dispatch across
+ * to-dos, projects, headings, and sidebar areas (spec §7). Every operand is
+ * resolved (task first, then area) and classified; a homogeneous set routes to
+ * its engine, and any illegal MIX gets one precise refusal:
+ *   - to-dos and/or projects → the in-place index/day/view engine (a to-do+project
+ *     set is legal only on the shared Today/Evening/day axes — that engine enforces
+ *     it); a pure-project set re-ranks its siblings;
+ *   - headings (one project) → the certified heading-block wire (#V11);
+ *   - areas → the sidebar-rank drag engine.
+ * A heading or area may not share a call with any other kind.
+ */
+export async function runUniversalReorder(deps, request, options = {}) {
+    if (request.uuids.length === 0) {
+        return refused("todo.move", "usage", "no items given — name at least one to reorder");
+    }
+    const classified = [];
+    for (const ref of request.uuids) {
+        const t = resolveMovee(deps, ref);
+        if (!(t instanceof ReferenceResolutionError)) {
+            const row = loadRow(deps.db, t.uuid);
+            if (row !== undefined) {
+                const kind = row.type === 1 ? "project" : row.type === 2 ? "heading" : "todo";
+                classified.push({ kind, uuid: t.uuid, ref, row });
+                continue;
+            }
+        }
+        // Not a task ref — try a sidebar area (areas live in TMArea, not TMTask).
+        const a = resolveArea(deps.db, { uuid: ref, title: ref });
+        if (a.resolved !== null) {
+            classified.push({ kind: "area", uuid: a.resolved.uuid, ref, title: a.resolved.title });
+            continue;
+        }
+        // Neither a task nor an area — surface an AMBIGUOUS task match (its candidates
+        // are the useful signal); a clean not-found names all four kinds.
+        if (t instanceof ReferenceResolutionError &&
+            t.candidates !== undefined &&
+            t.candidates.length > 0) {
+            return {
+                kind: "move-refused",
+                op: "todo.move",
+                refusal: "usage",
+                detail: t.message,
+                candidates: t.candidates,
+            };
+        }
+        return refused("todo.move", "usage", `no to-do, project, heading, or area matches "${ref}"`);
+    }
+    const kinds = new Set(classified.map((c) => c.kind));
+    const hasHeading = kinds.has("heading");
+    const hasArea = kinds.has("area");
+    // Mixed-kind refusal (item 2): only a to-do+project set may share a call (and
+    // only on a global axis, enforced downstream). A heading or an area never mixes.
+    if ((hasHeading || hasArea) && kinds.size > 1) {
+        const listed = classified.map((c) => `${c.ref} (${c.kind})`).join(", ");
+        return refused("todo.move", "usage", "one kind at a time — `reorder` rearranges a set of to-dos, a set of projects, a set of " +
+            `headings, OR a set of areas, but this set mixes kinds: ${listed}. Only to-dos and ` +
+            "projects intermix, and only on the shared Today/Evening/day axes.", "reorder each kind in its own call");
+    }
+    if (hasArea) {
+        if (request.in !== undefined) {
+            return refused("area.reorder", "usage", "`--in` names a to-do/project reorder axis — areas have a single sidebar-rank order, so " +
+                "it does not apply here", "drop --in; position the area(s) with --start / --end / --before / --after");
+        }
+        return runAreaReorderUniversal(deps, classified.filter((c) => c.kind === "area"), request.position, options);
+    }
+    if (hasHeading) {
+        if (request.in !== undefined) {
+            return refused("project.move-heading", "usage", "`--in` names a to-do/project reorder axis — a heading's order is the project's heading " +
+                "axis, so it does not apply here", "drop --in; position the heading(s) with --start / --end / --before / --after");
+        }
+        return runHeadingReorder(deps, classified.filter((c) => c.kind === "heading"), request.position, options);
+    }
+    // to-dos and/or projects: the existing in-place engine. A pure-project set routes
+    // through project.move; any to-do present routes through todo.move (which handles
+    // the to-do+project global-axis intermix and refuses a non-global mixed set).
+    const op = kinds.has("todo") ? "todo.move" : "project.move";
+    return runInPlaceReorder(deps, op, request, options);
+}
+/** The project's heading uuids in current display (index) order. */
+function currentHeadingOrder(deps, projectUuid) {
+    return deps.db
+        .prepare(`SELECT uuid FROM TMTask WHERE type = 2 AND trashed = 0 AND project = ? ORDER BY "index"`)
+        .all(projectUuid).map((r) => r.uuid);
+}
+/**
+ * Same-project heading re-ranking via the universal verb — dispatches onto the
+ * certified heading-block wire (`project.move-heading`), honoring #V11 (archived
+ * headings reorderable unguarded, with reopens disclosed). `project move-heading`
+ * remains the placement verb (cross-project / demotion); THIS is pure re-rank.
+ */
+async function runHeadingReorder(deps, headings, position, options) {
+    const op = "project.move-heading";
+    // One shared project (cross-container refusal, item 2).
+    const projectUuids = new Set(headings.map((h) => h.row.project));
+    if (projectUuids.size !== 1 || projectUuids.has(null)) {
+        const where = headings
+            .map((h) => `${h.uuid} in ${h.row.project === null ? "no project" : `project ${h.row.project}`}`)
+            .join("; ");
+        return refused(op, "blocked", `these headings span projects (${where}) — a heading reorder rearranges the headings of ONE project`, "reorder the headings of one project at a time");
+    }
+    const projectUuid = [...projectUuids][0];
+    const movees = headings.map((h) => h.uuid);
+    // Map the anchor grammar onto a HeadingPlacement. --start/--end → first/last;
+    // --before/--after resolve their ref to a heading of the SAME project (an anchor
+    // positions, never migrates); bare → the block at the earliest movee's slot.
+    let placement;
+    if (position !== undefined && ("before" in position || "after" in position)) {
+        const anchorRef = "before" in position ? position.before : position.after;
+        const ar = resolveMovee(deps, anchorRef);
+        if (ar instanceof ReferenceResolutionError) {
+            return {
+                kind: "move-refused",
+                op,
+                refusal: "usage",
+                detail: ar.message,
+                ...(ar.candidates !== undefined && { candidates: ar.candidates }),
+            };
+        }
+        const arow = loadRow(deps.db, ar.uuid);
+        if (arow === undefined || arow.type !== 2 || arow.project !== projectUuid) {
+            return refused(op, "blocked", `the anchor ${ar.uuid} is not a heading of the movees' project — an anchor positions, it never migrates`, "pick a heading anchor in that project, or use --start / --end");
+        }
+        placement = "before" in position ? { before: ar.uuid } : { after: ar.uuid };
+    }
+    else if (position !== undefined && "at" in position) {
+        placement = { position: position.at };
+    }
+    else {
+        const current = currentHeadingOrder(deps, projectUuid);
+        const moveeSet = new Set(movees);
+        const earliest = current.findIndex((u) => moveeSet.has(u));
+        const before = current.slice(0, Math.max(earliest, 0)).filter((u) => !moveeSet.has(u));
+        placement =
+            before.length > 0 ? { after: before[before.length - 1] } : { position: "first" };
+    }
+    // Compute the wire/reopened disclosure up front (both the dry-run plan and the ok
+    // note surface it) — computeHeadingMovePre also validates membership/anchor.
+    const pre = computeHeadingMovePre(deps.db, resolveProject(deps.db, { uuid: projectUuid }), movees, placement);
+    if (pre.problems.length > 0) {
+        return refused(op, "blocked", `heading reorder rejected: ${pre.problems.join("; ")}`, "reorder the headings of one project (read the project first)");
+    }
+    const touched = pre.wire.filter((u) => !movees.includes(u) && !pre.reopened.includes(u));
+    const reopenNote = pre.reopened.length > 0
+        ? `; re-ranking archived heading(s) ${pre.reopened.join(", ")} brought them back to open ` +
+            "(their children stay resolved)"
+        : "";
+    const result = await runMutation(deps, op, { project: { uuid: projectUuid }, headings: movees, placement }, { ...legOptions(options), ...(options.dryRun === true && { dryRun: true }) });
+    if (options.dryRun === true) {
+        return {
+            kind: "move-dry-run",
+            op,
+            plan: {
+                movees,
+                membership: "none (heading re-rank)",
+                placement: `move-heading → ${describePosition(position)}`,
+                placementClass: "guaranteed",
+                note: dryRunNote(result, "heading re-rank via the native heading-block wire") + reopenNote,
+            },
+        };
+    }
+    if (result.kind === "blocked") {
+        return {
+            kind: "move-refused",
+            op,
+            refusal: "blocked",
+            detail: result.detail,
+            ...(result.remediation !== undefined && { remediation: result.remediation }),
+            ...(result.hazard !== undefined && { hazard: result.hazard }),
+        };
+    }
+    if (result.kind !== "ok") {
+        return {
+            kind: "move-leg-failed",
+            op,
+            detail: `the heading re-rank did not complete (${result.kind})`,
+            failed: result,
+            completed: [],
+        };
+    }
+    return {
+        kind: "move-ok",
+        op,
+        movees: headings.map((h) => ({ uuid: h.uuid, title: h.row.title })),
+        membership: [],
+        placement: result,
+        placementClass: "guaranteed",
+        note: `reordered ${movees.length} heading(s) within project ${projectUuid}` +
+            reopenNote +
+            (touched.length > 0
+                ? `; also re-inserted ${touched.length} unnamed heading(s) to honor the order: ${touched.join(", ")}`
+                : ""),
+    };
+}
+/** Build the ordered single-area drag legs that realize a multi-area placement. */
+function planAreaLegs(areaUuids, position, anchorUuid) {
+    if ("at" in position) {
+        // first: drag last→first so the block ends up top-in-order; last: forward.
+        return position.at === "first"
+            ? areaUuids.toReversed().map((target) => ({ target, position: "first" }))
+            : areaUuids.map((target) => ({ target, position: "last" }));
+    }
+    if ("before" in position) {
+        // Each area dragged before the anchor, forward, lands them in order above it.
+        return areaUuids.map((target) => ({ target, before: anchorUuid }));
+    }
+    // after: chain each area after the previous (anchor → a → b → c).
+    const legs = [];
+    let prev = anchorUuid;
+    for (const target of areaUuids) {
+        legs.push({ target, after: prev });
+        prev = target;
+    }
+    return legs;
+}
+/**
+ * Sidebar-area re-ranking via the universal verb — dispatches onto `area.reorder`
+ * (the GUI sidebar-drag driver, the ONLY area-order surface, P6/O13). A single
+ * area is one drag; a set composes sequential drags (non-atomic, disclosed). The
+ * discriminating `things area reorder` alias reaches the same path.
+ */
+async function runAreaReorderUniversal(deps, areas, position, options) {
+    const op = "area.reorder";
+    if (position === undefined) {
+        return refused(op, "usage", "an area reorder needs a position — areas have no per-item bucket to assemble a block in", "use --start / --end, or --before / --after another area");
+    }
+    const movees = areas.map((a) => a.uuid);
+    let anchorUuid = null;
+    if ("before" in position || "after" in position) {
+        const anchorRef = "before" in position ? position.before : position.after;
+        const ar = resolveArea(deps.db, { uuid: anchorRef, title: anchorRef });
+        if (ar.resolved === null) {
+            return refused(op, "usage", `the anchor "${anchorRef}" did not resolve to an area`, "name an area (uuid or unique title) to anchor against");
+        }
+        anchorUuid = ar.resolved.uuid;
+        if (movees.includes(anchorUuid)) {
+            return refused(op, "blocked", "the anchor area cannot also be one of the moved areas — an anchor positions, it never migrates", "pick a different anchor area, or use --start / --end");
+        }
+    }
+    const legs = planAreaLegs(movees, position, anchorUuid);
+    const areaTitles = areas.map((a) => ({ uuid: a.uuid, title: a.title }));
+    if (options.dryRun === true) {
+        return {
+            kind: "move-dry-run",
+            op,
+            plan: {
+                movees,
+                membership: "none (sidebar drag)",
+                placement: `area re-rank → ${describePosition(position)}`,
+                placementClass: "guaranteed",
+                note: `${legs.length} sidebar-drag leg(s) — drives the local Things app, one drag per area`,
+            },
+        };
+    }
+    // Each leg is a full GUI-drive mutation; forward the drive acknowledgement.
+    const legOpts = {
+        ...legOptions(options),
+        ...(options.dangerouslyDriveGui !== undefined && {
+            dangerouslyDriveGui: options.dangerouslyDriveGui,
+        }),
+    };
+    const placed = [];
+    let last = null;
+    for (const leg of legs) {
+        const res = await runMutation(deps, op, leg, legOpts);
+        last = res;
+        if (res.kind === "blocked") {
+            // A blocked FIRST leg (nothing moved yet) hoists to a clean refusal; a
+            // blocked later leg is a partial-progress leg failure.
+            if (placed.length === 0) {
+                return {
+                    kind: "move-refused",
+                    op,
+                    refusal: "blocked",
+                    detail: res.detail,
+                    ...(res.remediation !== undefined && { remediation: res.remediation }),
+                    ...(res.hazard !== undefined && { hazard: res.hazard }),
+                };
+            }
+            return {
+                kind: "move-leg-failed",
+                op,
+                detail: `positioning ${leg.target} was blocked (${res.detail}) — ${placed.length} area(s) already moved`,
+                failed: res,
+                completed: [],
+            };
+        }
+        if (res.kind !== "ok") {
+            return {
+                kind: "move-leg-failed",
+                op,
+                detail: `positioning ${leg.target} did not complete (${res.kind}) — ${placed.length} area(s) already moved`,
+                failed: res,
+                completed: [],
+            };
+        }
+        placed.push(leg.target);
+    }
+    return {
+        kind: "move-ok",
+        op,
+        movees: areaTitles,
+        membership: [],
+        placement: last,
+        placementClass: "guaranteed",
+        note: `re-ranked ${areas.length} area(s) via ${legs.length} sidebar drag(s)` +
+            (legs.length > 1 ? " (sequential — non-atomic)" : ""),
+    };
+}
 // ---------------------------------------------------------------- shared core
 /**
- * The single STRICTLY-FUTURE day every movee shares (packed startDate), or null —
- * the precondition for the SIT4 dated `day` bounce (and the one-call `tomorrow`
- * sort). Members are to-dos in ANY container AND scheduled PROJECT rows (area-less
- * OR area-direct — SIT5 AREAPROJDAY proved the update-project when= legs preserve
- * the area FK), all on the SAME future day in the Today-bucket axis (startBucket=0).
- * A row off the day, a template, or an undated/arrived row breaks the group and
- * falls through to the normal single-container guard. (Templates never reach here:
- * startDate is NULL on a resting template, so `startDate === day` fails for them.)
+ * The packed day a single row contributes to a shared future day-group, or null.
+ * A SCHEDULED row (to-do or project) on a strictly-future startBucket=0 day
+ * contributes its `startDate`; a DEADLINE-FORECAST to-do (startDate NULL, future
+ * `deadline`, start IN (1,2) — DLBNC/§9o) contributes its `deadline` (they share the
+ * one block todayIndex axis). Any other row (arrived, undated non-forecast, off the
+ * Today axis) contributes null.
+ */
+function rowDayKey(row, packedToday) {
+    // A repeating TEMPLATE contributes its PROJECTION day (rt1_nextInstanceStartDate),
+    // the Upcoming day-block its rendered projection row sits in (TMPLSORT/PTMPL). Its
+    // startDate/deadline are NULL (or non-block), so it would otherwise contribute null;
+    // strictly-future gate mirrors the scheduled/forecast branches (an arrived/absent
+    // projection is not a future day-group member).
+    if (row.isTemplate) {
+        return row.templateProjectionDay !== null && row.templateProjectionDay > packedToday
+            ? row.templateProjectionDay
+            : null;
+    }
+    if (row.startDate !== null &&
+        row.startBucket === 0 &&
+        row.startDate > packedToday &&
+        (row.type === 0 || row.type === 1)) {
+        return row.startDate;
+    }
+    return forecastDeadlineDay(row, packedToday);
+}
+/**
+ * The single STRICTLY-FUTURE day every movee shares, or null — the precondition for
+ * the SIT4 dated `day` bounce (and the one-call `tomorrow` sort). Members are
+ * SCHEDULED to-dos in ANY container AND scheduled PROJECT rows (area-less OR area-
+ * direct — SIT5 AREAPROJDAY proved the update-project when= legs preserve the area
+ * FK) sharing a future startBucket=0 `startDate`, PLUS DEADLINE-FORECAST to-dos
+ * (DLBNC/§9o) whose future `deadline` equals that same day — all on the ONE Upcoming
+ * day-block todayIndex axis, so a scheduled+forecast mix is one group. A row off the
+ * day, a template, or an undated/arrived non-forecast row breaks the group and falls
+ * through to the normal single-container guard. (Templates never reach here: both
+ * `startDate` and `deadline` fail the strictly-future key for a resting template.)
  */
 function sharedFutureDay(rows, packedToday) {
     const first = rows[0];
     if (first === undefined)
         return null;
-    const day = first.startDate;
-    if (day === null || day <= packedToday || first.startBucket !== 0)
+    const day = rowDayKey(first, packedToday);
+    if (day === null)
         return null;
     for (const r of rows) {
-        if (r.startBucket !== 0 || r.startDate !== day)
-            return null;
-        if (r.type !== 0 && r.type !== 1)
-            return null;
-        if (r.isTemplate)
+        // Templates NO LONGER break the group: a strictly-future template projection is
+        // a first-class day-block member (TMPLSORT-3c-Tomorrow / PTMPL-B5), reached on the
+        // `tomorrow` native wire or the `day` per-class leg family (reorder.ts). rowDayKey
+        // returns its projection day, so an on-day template shares the group.
+        if (rowDayKey(r, packedToday) !== day)
             return null;
     }
     return day;
 }
+/** Whether any row in the group is a deadline-forecast member (DLBNC/§9o). */
+function hasForecastMember(rows, packedToday) {
+    return rows.some((r) => forecastDeadlineDay(r, packedToday) !== null);
+}
+/**
+ * The single shared FORECAST deadline day when EVERY row is a deadline-forecast
+ * member (§9o) of that one day, else null. Stricter than {@link sharedFutureDay}:
+ * a scheduled row (or a forecast row on a different day) breaks it — so a
+ * scheduled-only or scheduled+forecast-mixed set returns null (single-axis, day-
+ * only). Gates the forecast dual-axis refusal: only an all-forecast, one-day set
+ * has a coherent container-index alternative to the day-block.
+ */
+function sharedForecastDay(rows, packedToday) {
+    const first = rows[0];
+    if (first === undefined)
+        return null;
+    const day = forecastDeadlineDay(first, packedToday);
+    if (day === null)
+        return null;
+    for (const r of rows)
+        if (forecastDeadlineDay(r, packedToday) !== day)
+            return null;
+    return day;
+}
 /**
  * Reposition a shared FUTURE day-group on the global todayIndex axis — the SIT4
  * dated `day` bounce (loose/direct-area/headed/cross-container to-dos + area-less
@@ -1040,13 +1681,7 @@ async function runDayGroupReposition(deps, op, rows, position, options, scope, d
         };
     }
     if (placement.kind !== "ok") {
-        return {
-            kind: "move-leg-failed",
-            op,
-            detail: `the reorder leg did not complete (${placement.kind})`,
-            failed: placement,
-            completed: [],
-        };
+        return repositionFailed(op, placement);
     }
     return {
         kind: "move-ok",
@@ -1073,6 +1708,18 @@ async function repositionInPlace(deps, op, rows, position, packedToday, options,
     const axis = resolveReorderAxis(deps, op, rows, inTarget, packedToday, verb, position);
     if ("refused" in axis)
         return axis.refused;
+    // An explicit day-axis token (`--in <YYYY-MM-DD>` / `--in upcoming`) routes straight
+    // to the cross-container day-group reposition — membership + future-ness were
+    // validated in resolveReorderAxis. Mirror the auto-route's scope pick: the native
+    // one-call `tomorrow` sort only for a non-forecast group whose day is tomorrow (that
+    // surface re-dates a forecast row), else the dated `day` bounce.
+    if ("dayAxis" in axis) {
+        const day = axis.dayAxis;
+        const scope = !hasForecastMember(rows, packedToday) && day === packedTomorrowOf(packedToday)
+            ? "tomorrow"
+            : "day";
+        return runDayGroupReposition(deps, op, rows, position, options, scope, day);
+    }
     const targetOf = axis.targetOf;
     // On a forced/auto INDEX axis (a dual-axis set reordered within its container),
     // the display-bucket coherence guards below are the WRONG check: the members
@@ -1084,18 +1731,27 @@ async function repositionInPlace(deps, op, rows, position, packedToday, options,
     // A shared FUTURE day-group (single- OR cross-container) rides the global
     // todayIndex axis, not the normal single-container reorder: the SIT4 dated `day`
     // bounce (loose/direct-area/headed/cross-container to-dos + area-less project
-    // rows, any mix), or the one-call `list "Tomorrow"` sort when the day is
-    // tomorrow. The ONLY exception is a single UNHEADED PROJECT container — its same-
-    // day children ride the cheaper atomic native container-day re-rank, so it falls
-    // through to the normal path below (reorderTargetOf → container-day). Templates
-    // and area-direct project rows are excluded by sharedFutureDay.
+    // rows + DEADLINE-FORECAST to-dos, any mix), or the one-call `list "Tomorrow"`
+    // sort when the day is tomorrow. Two exceptions force the `day` scope (never the
+    // native short-cuts): a group CONTAINING a forecast row NEVER rides `list
+    // "Tomorrow"` (that surface re-dates a forecast row, UPCDL-5) NOR the single-
+    // project container-day native re-rank (a forecast row has no startDate, so it is
+    // not a container-day scheduled child) — the deadline-cycle `day` bounce is the
+    // one surface that serves the mixed group. Otherwise a single UNHEADED PROJECT
+    // container's same-day scheduled children ride the cheaper atomic native
+    // container-day re-rank (fall through to reorderTargetOf → container-day).
+    // Templates are excluded by sharedFutureDay. The auto-route NEVER fires on a
+    // forced/auto INDEX axis (indexAxis === true): an explicit `--in someday` /
+    // `--in anytime` / `--in <container>` on a same-day forecast set is the certified
+    // container `index` re-rank, and must not be overridden by the day bounce.
     const structKeys = new Set(rows.map((r) => structuralKey(r, packedToday)));
     const sharedDay = sharedFutureDay(rows, packedToday);
-    if (sharedDay !== null) {
+    if (sharedDay !== null && !indexAxis) {
+        const forecastInGroup = hasForecastMember(rows, packedToday);
         const soleStruct = structKeys.size === 1 ? structKeys.values().next().value : null;
-        const singleProjectContainer = soleStruct?.startsWith("project:") ?? false;
+        const singleProjectContainer = !forecastInGroup && (soleStruct?.startsWith("project:") ?? false);
         if (!singleProjectContainer) {
-            const scope = sharedDay === packedTomorrowOf(packedToday) ? "tomorrow" : "day";
+            const scope = !forecastInGroup && sharedDay === packedTomorrowOf(packedToday) ? "tomorrow" : "day";
             return runDayGroupReposition(deps, op, rows, position, options, scope, sharedDay);
         }
     }
@@ -1204,13 +1860,7 @@ async function repositionInPlace(deps, op, rows, position, packedToday, options,
         };
     }
     if (placement.kind !== "ok") {
-        return {
-            kind: "move-leg-failed",
-            op,
-            detail: `the reorder leg did not complete (${placement.kind})`,
-            failed: placement,
-            completed: [],
-        };
+        return repositionFailed(op, placement);
     }
     return {
         kind: "move-ok",
@@ -1484,7 +2134,9 @@ function bucketMembers(deps, target, dayAnchor) {
         ...(target.container !== undefined && { container: { uuid: target.container } }),
     };
     const containerUuid = target.container ?? null;
-    const pre = computeReorderPre(deps.db, params, containerUuid, deps.now?.() ?? new Date());
+    const pre = computeReorderPre(deps.db, params, containerUuid, deps.now?.() ?? new Date(), {
+        zone: deps.zone,
+    });
     return pre.members.map((m) => m.uuid);
 }
 function legOptions(options) {