things-api 0.11.0 → 0.13.0

package/dist/write/pre-state.js

@@ -1,10 +1,11 @@
 import { encodePackedDate, localToday } from "../model/dates.js";
 import { TASK_STATUS_FROM_DB } from "../model/entities.js";
 import { byUuid } from "../read/detail.js";
-import { resolveNamedRef } from "../read/queries.js";
+import { deadNameMatchHint, resolveHeadingRef, resolveNamedRef } from "../read/queries.js";
 export function emptyPreState() {
     return {
         target: null,
+        todayIso: localToday(new Date()),
         destProject: null,
         destProjectStatus: null,
         destArea: null,
@@ -14,6 +15,7 @@ export function emptyPreState() {
         parentTag: null,
         entityTarget: null,
         childTags: [],
+        areaMembers: null,
         openChildren: [],
         canceledChildren: [],
         completedChildren: [],
@@ -26,8 +28,62 @@ export function emptyPreState() {
         projectRepeat: null,
         repeatSubtreeUuids: null,
         headingConvert: null,
+        headingMove: null,
+        headingMoveToProject: null,
+        headingDissolve: null,
     };
 }
+/**
+ * Read a project's current heading order and compute the FULL target order
+ * after moving `headings` (an ordered block) to the requested placement. The
+ * block lands contiguously in selection order; every other heading keeps its
+ * relative order. Children follow their heading on the wire (scf P1). Illegal
+ * requests (unknown/duplicated movee, an anchor that is a movee or absent)
+ * collect problems and leave the order unchanged.
+ */
+export function computeHeadingMovePre(db, project, headings, placement) {
+    const projectUuid = project.resolved?.uuid ?? "";
+    const current = db
+        .prepare(`SELECT uuid FROM TMTask WHERE type = 2 AND trashed = 0 AND project = ? ORDER BY "index"`)
+        .all(projectUuid).map((r) => r.uuid);
+    const problems = [];
+    const currentSet = new Set(current);
+    const movees = new Set();
+    for (const h of headings) {
+        if (movees.has(h))
+            problems.push(`heading ${h} listed more than once`);
+        movees.add(h);
+    }
+    if (headings.length === 0)
+        problems.push("no headings given");
+    for (const h of headings) {
+        if (!currentSet.has(h))
+            problems.push(`${h} is not a heading of this project`);
+    }
+    let anchor = null;
+    if ("before" in placement || "after" in placement) {
+        anchor = "before" in placement ? placement.before : placement.after;
+        if (!currentSet.has(anchor)) {
+            problems.push(`anchor heading ${anchor} is not a heading of this project`);
+        }
+        if (movees.has(anchor)) {
+            problems.push("the anchor heading cannot also be one of the moved headings");
+        }
+    }
+    if (problems.length > 0)
+        return { project, current, targetOrder: current, problems };
+    const rest = current.filter((u) => !movees.has(u));
+    let targetOrder;
+    if ("position" in placement) {
+        targetOrder = placement.position === "first" ? [...headings, ...rest] : [...rest, ...headings];
+    }
+    else {
+        const idx = rest.indexOf(anchor);
+        const insertAt = "before" in placement ? idx : idx + 1;
+        targetOrder = [...rest.slice(0, insertAt), ...headings, ...rest.slice(insertAt)];
+    }
+    return { project, current, targetOrder, problems: [] };
+}
 /**
  * The uuids of a project's source subtree rows (non-trashed to-dos AND
  * headings, direct or heading-nested). `childrenReplaced` counts how many of
@@ -68,6 +124,144 @@ export function classifyHeadingConvert(db, target) {
     }
     return { kind: "ok", projectReveal: project.uuid, ordinal };
 }
+export function classifyHeadingMoveToProject(db, project, headingSel, toProject) {
+    const src = resolveProject(db, project);
+    if (src.resolved === null) {
+        return {
+            kind: "refuse",
+            refusal: "no-source",
+            detail: src.matches > 1
+                ? "the source project title is ambiguous — pass its uuid"
+                : "the source project did not resolve",
+        };
+    }
+    const h = resolveHeading(db, src.resolved.uuid, headingSel);
+    if (h.resolved === null) {
+        return {
+            kind: "refuse",
+            refusal: h.matches > 1 ? "heading-ambiguous" : "heading-not-found",
+            detail: h.matches > 1
+                ? `the heading selector "${headingSel}" matches ${h.matches} headings in the project — disambiguate with a uuid`
+                : `no heading matching "${headingSel}" in the source project`,
+        };
+    }
+    const headingRow = db
+        .prepare("SELECT title FROM TMTask WHERE uuid = ? AND type = 2 AND trashed = 0")
+        .get(h.resolved.uuid);
+    if (headingRow === undefined) {
+        return { kind: "refuse", refusal: "heading-not-found", detail: "the heading no longer exists" };
+    }
+    const title = headingRow.title ?? "";
+    if (title === "") {
+        return {
+            kind: "refuse",
+            refusal: "empty-heading-title",
+            detail: "the heading has no title — the Move… drive addresses the heading by its title-carrying " +
+                '"More. <title>" button, which cannot pick one titleless heading out of several',
+        };
+    }
+    // Source title-collision: the "More. <title>" node cannot tell two same-titled
+    // headings in one project apart, even when the SELECTOR resolved by uuid.
+    const twins = db
+        .prepare("SELECT uuid FROM TMTask WHERE type = 2 AND trashed = 0 AND project = ? AND title = ? AND uuid != ?")
+        .all(src.resolved.uuid, title, h.resolved.uuid);
+    if (twins.length > 0) {
+        return {
+            kind: "refuse",
+            refusal: "heading-ambiguous",
+            detail: `the heading title "${title}" is shared by ${twins.length + 1} headings in this project — ` +
+                "the ellipsis Move… drive addresses headings by title and cannot disambiguate; " +
+                "rename one first",
+            candidates: [h.resolved.uuid, ...twins.map((t) => t.uuid)],
+        };
+    }
+    const dest = resolveProject(db, toProject);
+    if (dest.resolved === null) {
+        return {
+            kind: "refuse",
+            refusal: "no-dest",
+            detail: dest.matches > 1
+                ? "the destination project title is ambiguous — pass its uuid"
+                : "the destination project did not resolve",
+        };
+    }
+    if (dest.resolved.uuid === src.resolved.uuid) {
+        return {
+            kind: "refuse",
+            refusal: "same-project",
+            detail: "the destination is the heading's current project — use `project move-heading` to reorder " +
+                "a heading WITHIN its project",
+        };
+    }
+    // Destination picker-collision: the picker searches BY TITLE, so a shared dest
+    // title would filter to >1 project and Return would pick the wrong one — fail
+    // closed even though the destination itself resolved (possibly by uuid).
+    const destTitle = dest.resolved.title;
+    const destTwins = db
+        .prepare("SELECT COUNT(*) AS n FROM TMTask WHERE type = 1 AND trashed = 0 AND title = ? AND uuid != ?")
+        .get(destTitle, dest.resolved.uuid);
+    if (destTwins.n > 0) {
+        return {
+            kind: "refuse",
+            refusal: "dest-ambiguous",
+            detail: `the destination title "${destTitle}" is shared by ${destTwins.n + 1} projects — the ` +
+                "Move… picker searches by title and would land the heading in the wrong one; rename or " +
+                "merge the duplicates first",
+        };
+    }
+    return {
+        kind: "ok",
+        pre: {
+            sourceProjectUuid: src.resolved.uuid,
+            headingUuid: h.resolved.uuid,
+            headingTitle: title,
+            destProjectUuid: dest.resolved.uuid,
+            destProjectTitle: destTitle,
+        },
+    };
+}
+export function classifyHeadingDissolve(db, target) {
+    if (target === null || target.type !== "heading") {
+        return { kind: "refuse", refusal: "not-a-heading", detail: "target is not a heading" };
+    }
+    const project = target.project;
+    if (project === null) {
+        return {
+            kind: "refuse",
+            refusal: "no-project",
+            detail: "the heading has no owning project — cannot reveal a project view to drive its row",
+        };
+    }
+    const title = target.title;
+    if (title === "") {
+        return {
+            kind: "refuse",
+            refusal: "empty-title",
+            detail: "the heading has no title — the Delete drive addresses the heading by its title-carrying " +
+                '"More. <title>" button, which cannot pick one titleless heading out of several',
+        };
+    }
+    const twins = db
+        .prepare("SELECT uuid FROM TMTask WHERE type = 2 AND trashed = 0 AND project = ? AND title = ? AND uuid != ?")
+        .all(project.uuid, title, target.uuid);
+    if (twins.length > 0) {
+        return {
+            kind: "refuse",
+            refusal: "title-ambiguous",
+            detail: `the heading title "${title}" is shared by ${twins.length + 1} headings in this project — ` +
+                "the ellipsis Delete drive addresses headings by title and cannot disambiguate; " +
+                "rename one first",
+            candidates: [target.uuid, ...twins.map((t) => t.uuid)],
+        };
+    }
+    const childUuids = db
+        .prepare('SELECT uuid FROM TMTask WHERE type = 0 AND trashed = 0 AND status = 0 AND heading = ? ORDER BY "index"')
+        .all(target.uuid).map((r) => r.uuid);
+    return {
+        kind: "ok",
+        pre: { projectReveal: project.uuid, headingUuid: target.uuid, headingTitle: title, childUuids },
+    };
+}
 /**
  * Count non-trashed projects with the given title that share the target's
  * row-selection container, EXCLUDING the target itself. A non-zero count is a
@@ -155,18 +349,36 @@ export function classifyProjectRepeat(db, target) {
 export function resolveArea(db, ref) {
     return resolveNamedRef(db, "TMArea", "1=1", [], ref.uuid ?? ref.title ?? "");
 }
+/**
+ * Resolve a project DESTINATION (`--to-project` / `--project` on add/move). NAME
+ * resolution is OPEN-only (`status = 0`) — a completed/canceled project is not a
+ * valid live destination by name: placing an open child there strands it (PLOG1,
+ * "a completed-in-place project strands children identically, one sweep later").
+ * A UUID / partial-uuid still reaches a completed project (explicit intent —
+ * `nameExtraWhere` narrows the NAME tiers only). When a name matches ONLY non-open
+ * projects, the resolution carries a `deadHint` so the destination not-found says
+ * the row exists and how to reach it (by uuid), instead of a bare "project not
+ * found".
+ */
 export function resolveProject(db, ref) {
-    return resolveNamedRef(db, "TMTask", "type = 1 AND trashed = 0", [], ref.uuid ?? ref.title ?? "");
+    const key = ref.uuid ?? ref.title ?? "";
+    const r = resolveNamedRef(db, "TMTask", "type = 1 AND trashed = 0", [], key, {
+        nameExtraWhere: "status = 0",
+    });
+    if (r.resolved === null && r.matches === 0) {
+        const completed = resolveNamedRef(db, "TMTask", "type = 1 AND trashed = 0 AND status != 0", [], key, {
+            prefixTier: false,
+        }).matches;
+        if (completed > 0)
+            return { ...r, deadHint: deadNameMatchHint({ completed }) };
+    }
+    return r;
 }
-export function resolveHeading(db, projectUuid, headingTitle) {
-    const rows = db
-        .prepare("SELECT uuid, title FROM TMTask WHERE type = 2 AND trashed = 0 AND project = ? AND title = ? COLLATE NOCASE")
-        .all(projectUuid, headingTitle);
-    const first = rows[0];
-    return {
-        resolved: rows.length === 1 && first !== undefined ? first : null,
-        matches: rows.length,
-    };
+export function resolveHeading(db, projectUuid, headingSel) {
+    // Shares the one heading-selector core (title | uuid | empty-string literal,
+    // no ordinal) with the project heading verbs — see resolveHeadingRef.
+    const r = resolveHeadingRef(db, projectUuid, headingSel);
+    return { resolved: r.resolved, matches: r.matches };
 }
 export function projectStatus(db, uuid) {
     const row = db.prepare("SELECT status FROM TMTask WHERE uuid = ? AND type = 1").get(uuid);
@@ -222,6 +434,22 @@ export function childTagTitles(db, tagUuid) {
         .all(tagUuid, tagUuid);
     return rows.map((r) => r.title);
 }
+/**
+ * Live member census for `area.delete` (A25/A25B). Counts the area's non-trashed
+ * DIRECT members: to-dos carrying the area FK (any status — a logged to-do is
+ * still trashed by the delete) and projects carrying the area FK. Deleting a
+ * non-empty area trashes the to-dos and takes the projects with it, so the guard
+ * uses these counts to refuse fail-closed unless the caller allows it.
+ */
+export function areaMemberCounts(db, areaUuid) {
+    const todos = db
+        .prepare("SELECT COUNT(*) AS n FROM TMTask WHERE type = 0 AND trashed = 0 AND area = ?")
+        .get(areaUuid).n;
+    const projects = db
+        .prepare("SELECT COUNT(*) AS n FROM TMTask WHERE type = 1 AND trashed = 0 AND area = ?")
+        .get(areaUuid).n;
+    return { projects, todos };
+}
 export function trashedCount(db) {
     const row = db.prepare("SELECT COUNT(*) AS n FROM TMTask WHERE trashed = 1").get();
     return row.n;
@@ -230,6 +458,7 @@ export function isRepeatingTemplate(task) {
     return task !== null && task.type !== "heading" && task.repeating.isTemplate;
 }
 const NOT_TEMPLATE_ROW = "(rt1_recurrenceRule IS NULL AND repeater IS NULL)";
+const TEMPLATE_ROW = "(rt1_recurrenceRule IS NOT NULL OR repeater IS NOT NULL)";
 /**
  * Scope membership + full wire list for `reorder`. Eligibility mirrors the
  * lab evidence exactly:
@@ -246,8 +475,6 @@ const NOT_TEMPLATE_ROW = "(rt1_recurrenceRule IS NULL AND repeater IS NULL)";
  *             unprobed and the guard rejects them.
  *  - inbox:   unscheduled to-dos with no container (start=0), by "index"
  *             (A6/P8a — the command ranks the sent list in order).
- *  - headings: the HEADING rows (type=2) of a project, by "index" (scf P1 —
- *             the private command accepts heading uuids; children follow).
  *  - someday: loose someday to-dos AND area-less someday projects, by
  *             "index"; same-type requests only. The Someday list handler is
  *             anchor-stacked with OPPOSITE stack directions by row type:
@@ -260,12 +487,37 @@ const NOT_TEMPLATE_ROW = "(rt1_recurrenceRule IS NULL AND repeater IS NULL)";
 export function computeReorderPre(db, params, containerUuid, now) {
     const todayIso = localToday(now);
     const packedToday = encodePackedDate(todayIso);
-    const key = params.scope === "today" || params.scope === "evening" ? "todayIndex" : "index";
-    const select = (where, binds, rankCol) => db
-        .prepare(`SELECT uuid, title, ${rankCol} AS rank, startBucket, type FROM TMTask
-         WHERE trashed = 0 AND status = 0 AND ${NOT_TEMPLATE_ROW} AND ${where}
-         ORDER BY ${rankCol} ASC`)
-        .all(...binds);
+    const key = params.scope === "today" ||
+        params.scope === "evening" ||
+        params.scope === "container-day" ||
+        params.scope === "day" ||
+        params.scope === "tomorrow" ||
+        params.scope === "upcoming"
+        ? "todayIndex"
+        : "index";
+    const rowsOf = (where, binds, rankCol, templateClause) => db
+        .prepare(`SELECT uuid, title, ${rankCol} AS rank, startBucket, type, ${TEMPLATE_ROW} AS isTemplate
+           FROM TMTask
+           WHERE trashed = 0 AND status = 0 AND ${templateClause} AND ${where}
+           ORDER BY ${rankCol} ASC`)
+        .all(...binds).map((r) => {
+        const m = {
+            uuid: r.uuid,
+            title: r.title,
+            rank: r.rank,
+            startBucket: r.startBucket,
+            type: r.type,
+            isTemplate: r.isTemplate === 1,
+        };
+        return m;
+    });
+    // Every scope EXCEPT the day-block scopes excludes templates (NOT_TEMPLATE_ROW).
+    const select = (where, binds, rankCol) => rowsOf(where, binds, rankCol, NOT_TEMPLATE_ROW);
+    // The `day`/`tomorrow` day-block scopes ADMIT templates as first-class members
+    // (their strictly-future projection sits on the block todayIndex axis — TMPLSORT/
+    // PTMPL); the leg family in reorder.ts splits per class (never a when=/deadline leg
+    // on a template — the §1 crash).
+    const selectWithTemplates = (where, binds) => rowsOf(where, binds, "todayIndex", "1=1");
     let members = [];
     const rejectedCandidates = new Map();
     switch (params.scope) {
@@ -317,10 +569,6 @@ export function computeReorderPre(db, params, containerUuid, now) {
             members = select("type = 0 AND start = 0", [], `"index"`);
             break;
         }
-        case "headings": {
-            members = select("type = 2 AND project = ?", [containerUuid ?? ""], `"index"`);
-            break;
-        }
         case "someday": {
             // Loose someday to-dos AND area-less someday projects (P9e locked the
             // project protocol) — same-type requests only, like the area scope.
@@ -351,6 +599,178 @@ export function computeReorderPre(db, params, containerUuid, now) {
             }
             break;
         }
+        case "heading": {
+            // A heading's ANYTIME children, ranked on "index". The forward-order
+            // bounce back-inserts each (BOUNCE2-h); templates + scheduled/someday
+            // children are not members of this bucket.
+            members = select("type = 0 AND heading = ? AND start = 1 AND startDate IS NULL", [containerUuid ?? ""], `"index"`);
+            break;
+        }
+        case "area-someday": {
+            // An area's SOMEDAY direct members (unheaded), ranked on "index". The
+            // reverse-order bounce front-inserts each (SOMEBNC-area) — the state-
+            // preserving surface the destructive area reorder command lacks (§9f).
+            members = select("type = 0 AND area = ? AND heading IS NULL AND start = 2 AND startDate IS NULL", [containerUuid ?? ""], `"index"`);
+            break;
+        }
+        case "anytime": {
+            // Area-less loose ANYTIME to-dos, ranked on "index". The reverse-order
+            // bounce front-inserts each below the running global min (ANYBNC).
+            members = select("type = 0 AND project IS NULL AND area IS NULL AND heading IS NULL " +
+                "AND start = 1 AND startDate IS NULL", [], `"index"`);
+            break;
+        }
+        case "container-day": {
+            // A container's (project OR area) same-day scheduled children, ranked on
+            // todayIndex, date-preserving (DAYORD-b). The day is read off the first
+            // requested uuid — the planner guarantees every movee shares the bucket
+            // (rule 4). startBucket=0 (today-proper / a future day); the evening
+            // sub-bucket stays app-default (unprobed for the container specifier).
+            const firstUuid = params.uuids[0];
+            const first = firstUuid !== undefined
+                ? db
+                    .prepare("SELECT startDate, startBucket FROM TMTask WHERE uuid = ?")
+                    .get(firstUuid)
+                : undefined;
+            if (first?.startDate != null && first.startBucket === 0) {
+                members = select("type = 0 AND heading IS NULL AND (project = ? OR area = ?) " +
+                    "AND startBucket = 0 AND startDate = ?", [containerUuid ?? "", containerUuid ?? "", first.startDate], "todayIndex");
+            }
+            break;
+        }
+        case "day": {
+            // The DATED BOUNCE (SIT4 DAYBNC): a whole ARBITRARY future day-group across
+            // ALL containers, ranked on todayIndex. SCHEDULED members are every to-do on
+            // the day (loose, project-child, headed-child, area-direct — the when= round-
+            // trip preserves each container FK, incl. the heading FK, §2e/R21) PLUS every
+            // scheduled PROJECT row on the day (type=1 rows front-insert on the SAME
+            // global todayIndex axis, DAYBNC DP-1/DP-2 — the leg is update-project).
+            // DEADLINE-FORECAST members (DLBNC / #383) are ALSO first-class day-block
+            // members: someday/anytime-stage to-dos (start IN (1,2)) whose future
+            // `deadline` == D and whose `startDate` is NULL rest on the SAME Upcoming
+            // day-block todayIndex axis (§9o / DLBNC-1d), reordered by the deadline-cycle
+            // (URL deadline= clear + re-set) rather than the when= bounce. The two classes
+            // are merged and re-sorted by todayIndex into the true interleaved block order.
+            // The whole group is one bounce unit (a reverse-target pass re-bases it below
+            // the day's global min), so every same-day member is enumerated — an
+            // untouched row is just an unrequested member (co-bounced + disclosed as
+            // `touched`), never a strand. The day D is read off the first requested uuid
+            // (its startDate when scheduled, else its deadline when forecast). Templates
+            // are excluded by NOT_TEMPLATE_ROW.
+            const firstUuid = params.uuids[0];
+            const first = firstUuid !== undefined
+                ? db
+                    .prepare("SELECT startDate, startBucket, deadline, start, rt1_nextInstanceStartDate AS proj, " +
+                    `${TEMPLATE_ROW} AS isTemplate FROM TMTask WHERE uuid = ?`)
+                    .get(firstUuid)
+                : undefined;
+            // The day D read off the first requested uuid: a scheduled row's startDate, a
+            // forecast row's deadline, or a TEMPLATE's projection day (rt1_nextInstanceStart
+            // Date — TMPLSORT/PTMPL). Threaded into all three member cohorts below.
+            const dayPacked = first === undefined
+                ? null
+                : first.isTemplate === 1
+                    ? first.proj
+                    : first.startDate !== null && first.startBucket === 0
+                        ? first.startDate
+                        : first.startDate === null && (first.start === 1 || first.start === 2)
+                            ? first.deadline
+                            : null;
+            if (dayPacked !== null) {
+                const scheduled = select("type IN (0, 1) AND startBucket = 0 AND startDate = ?", [dayPacked], "todayIndex");
+                // §9o deadline-forecast cohort: start IN (1,2), startDate NULL, deadline == D.
+                // To-dos AND PROJECTS (type IN (0,1)) — forecast projects are first-class
+                // members of the SAME block todayIndex axis, interleaved with forecast to-dos
+                // (PROJDL-2a/2c, #385), reordered by the update-project deadline-cycle.
+                const forecast = select("type IN (0, 1) AND startDate IS NULL AND deadline = ? AND start IN (1, 2)", [dayPacked], "todayIndex");
+                // Repeating TEMPLATE projections on day D (TMPLSORT-3c / PTMPL-B5): to-do AND
+                // project templates whose rt1_nextInstanceStartDate == D render on the SAME
+                // block todayIndex axis. Admitted as members so the dispatch can split the
+                // per-class leg family; a PROJECT template is byte-untouched under the suffix
+                // rule, a TO-DO template front-inserts via a single-id `list "Upcoming"` leg.
+                const templates = selectWithTemplates(`type IN (0, 1) AND ${TEMPLATE_ROW} AND rt1_nextInstanceStartDate = ?`, [dayPacked]);
+                // One shared todayIndex axis (DLBNC-1d / TMPLSORT-2): merge + re-sort to block order.
+                members = [...scheduled, ...forecast, ...templates].toSorted((a, b) => a.rank - b.rank);
+            }
+            // An INBOX-stage row (start=0) carrying this deadline is OFF the block axis
+            // (todayIndex=0, §9o — the axis assignment is gated on start IN (1,2), not the
+            // bare deadline), so it is refused with an honest, unprobed-membership reason.
+            // Templates are NO LONGER rejected — they are first-class day-block members above
+            // (their leg family, never a dated when= leg, is compiled in reorder.ts). Area-
+            // direct project rows are scheduled members (SIT5 AREAPROJDAY).
+            for (const uuid of params.uuids) {
+                const t = db
+                    .prepare("SELECT start, startDate, deadline, rt1_recurrenceRule AS rule, repeater " +
+                    "FROM TMTask WHERE uuid = ?")
+                    .get(uuid);
+                if (t === undefined)
+                    continue;
+                if (t.rule !== null || t.repeater !== null)
+                    continue;
+                if (dayPacked !== null &&
+                    t.start === 0 &&
+                    t.startDate === null &&
+                    t.deadline !== null &&
+                    t.deadline === dayPacked) {
+                    rejectedCandidates.set(uuid, "is an INBOX-stage row (start=0) with this deadline — it rests OFF the Upcoming " +
+                        "day-block axis (todayIndex=0, §9o: the block axis is gated on start IN (1,2), " +
+                        "not the bare deadline), so its position there is unprobed; schedule it or move it " +
+                        "out of the Inbox before reordering it on the day axis");
+                }
+            }
+            break;
+        }
+        case "tomorrow": {
+            // The whole TOMORROW day-group across ALL containers (ORDFIN2 TOMORROWLIST),
+            // ranked on todayIndex. `list "Tomorrow"` is a clean one-call native surface
+            // that ACCEPTS a scheduled PROJECT row inline (type=1, O12 analog) and re-
+            // ranks it in position — so members are type IN (0,1), and a project row is a
+            // valid MOVEE here (the ONLY reorder scope that accepts one on the day axis).
+            // The day is read off the first requested uuid; the planner guarantees it is
+            // tomorrow. Repeating TEMPLATES whose projection == tomorrow are ALSO first-
+            // class members of this one-call wire (TMPLSORT-3c-Tomorrow to-do templates /
+            // PTMPL-B5 project templates: the native `list "Tomorrow"` reorder places a
+            // template at its exact sent slot, umd-silent, no reparent, no crash) — the
+            // native surface is the ONE safe way to position a template on the day axis.
+            const firstUuid = params.uuids[0];
+            const first = firstUuid !== undefined
+                ? db
+                    .prepare("SELECT startDate, startBucket, rt1_nextInstanceStartDate AS proj, " +
+                    `${TEMPLATE_ROW} AS isTemplate FROM TMTask WHERE uuid = ?`)
+                    .get(firstUuid)
+                : undefined;
+            const dayPacked = first === undefined
+                ? null
+                : first.isTemplate === 1
+                    ? first.proj
+                    : first.startBucket === 0
+                        ? first.startDate
+                        : null;
+            if (dayPacked !== null) {
+                const scheduled = select("type IN (0, 1) AND startBucket = 0 AND startDate = ?", [dayPacked], "todayIndex");
+                const templates = selectWithTemplates(`type IN (0, 1) AND ${TEMPLATE_ROW} AND rt1_nextInstanceStartDate = ?`, [dayPacked]);
+                members = [...scheduled, ...templates].toSorted((a, b) => a.rank - b.rank);
+            }
+            break;
+        }
+        case "heading-someday": {
+            // A heading's SOMEDAY children, ranked on "index" (HEADSUB1 Arm B-someday /
+            // Arm C). Re-heading the block in forward target order BACK-INSERTS each
+            // deterministically (start=2 preserved) — the move-to-heading sort. Same
+            // bucket shape as the `heading` anytime scope, `start=2` instead of `start=1`.
+            members = select("type = 0 AND heading = ? AND start = 2 AND startDate IS NULL", [containerUuid ?? ""], `"index"`);
+            break;
+        }
+        case "upcoming": {
+            // INTERNAL per-template front-insert leg (the `day` dispatch, TMPLSORT-1). The
+            // sent id(s) are TRUSTED day-block members already validated by the day
+            // dispatch — populate directly (so the H-REORDER-SCOPE guard passes) and let
+            // the wire be the sent id(s) only (no extension). Never a user scope.
+            if (params.uuids.length > 0) {
+                members = selectWithTemplates(`uuid IN (${params.uuids.map(() => "?").join(", ")})`, params.uuids);
+            }
+            break;
+        }
     }
     const seen = new Set();
     const duplicates = [];
@@ -399,6 +819,7 @@ export function computeReorderPre(db, params, containerUuid, now) {
             rank: m.rank,
             startBucket: m.startBucket,
             type: m.type,
+            isTemplate: m.isTemplate,
         })),
         rejected,
         duplicates,
@@ -411,7 +832,28 @@ function rowStartDate(db, uuid) {
     const row = db.prepare("SELECT startDate FROM TMTask WHERE uuid = ?").get(uuid);
     return row?.startDate ?? null;
 }
-export function projectOf(task) {
-    return task !== null && task.type === "project" ? task : null;
+/**
+ * A row's live Today/Evening flag — `"today"`, `"evening"`, or `null` — read
+ * from the SAME marker the `today`/`evening` reorder membership uses
+ * ({@link computeReorderPre}, O01/O03/§9n): an ARRIVED scheduled row
+ * (`start IN (1,2)` AND `startDate <= today`) carries the flag — `evening` at
+ * raw `startBucket=1` (a live evening flag expires daily, so a stale past-dated
+ * bucket-1 row reads `today` proper), `today` otherwise. Someday, anytime,
+ * inbox, and future-scheduled rows carry NO flag. Single-sourced here so any
+ * de-Today guard (e.g. the `projects` bounce's de-star refusal in reorder.ts)
+ * keys off the one marker and can never drift from the membership query.
+ */
+export function todayEveningFlagOf(db, uuid, now) {
+    const packedToday = encodePackedDate(localToday(now));
+    const row = db
+        .prepare("SELECT start, startDate, startBucket FROM TMTask WHERE uuid = ?")
+        .get(uuid);
+    if (row === undefined)
+        return null;
+    if (row.start !== 1 && row.start !== 2)
+        return null; // inbox (start=0)
+    if (row.startDate === null || row.startDate > packedToday)
+        return null; // someday / anytime / future
+    return row.startBucket === 1 && row.startDate === packedToday ? "evening" : "today";
 }
 //# sourceMappingURL=pre-state.js.map