things-api 0.12.0 → 0.13.0

package/dist/write/move.js

@@ -8,13 +8,15 @@ 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,137 @@ 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);
 }
 // ---------------------------------------------------------------- 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 +1372,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 +1399,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 +1422,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 +1551,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",