forge-openclaw-plugin 0.2.26 → 0.2.28

package/dist/server/server/src/movement.js

@@ -8,6 +8,7 @@ import { createManualRewardGrant } from "./repositories/rewards.js";
 import { listTaskRuns } from "./repositories/task-runs.js";
 import { getDefaultUser } from "./repositories/users.js";
 import { listWikiSpaces } from "./repositories/wiki-memory.js";
+import { getScreenTimeOverlapSummary } from "./screen-time.js";
 const movementPublishModeSchema = z.enum([
     "auto_publish",
     "draft_review",
@@ -274,6 +275,61 @@ export const movementTripPatchSchema = z.object({
     tags: z.array(z.string().trim()).optional(),
     metadata: z.record(z.string(), z.unknown()).optional()
 });
+const movementBoxKindSchema = z.enum(["stay", "trip", "missing"]);
+const movementBoxSourceKindSchema = z.enum(["automatic", "user_defined"]);
+const movementBoxOriginSchema = z.enum([
+    "recorded",
+    "continued_stay",
+    "repaired_gap",
+    "missing",
+    "user_defined",
+    "user_invalidated"
+]);
+const movementUserBoxSchemaBase = z.object({
+    kind: movementBoxKindSchema,
+    startedAt: z.string().datetime(),
+    endedAt: z.string().datetime(),
+    title: z.string().trim().default(""),
+    subtitle: z.string().trim().default(""),
+    placeLabel: z.string().trim().nullable().default(null),
+    anchorExternalUid: z.string().trim().min(1).nullable().default(null),
+    tags: z.array(z.string().trim()).default([]),
+    distanceMeters: z.number().nonnegative().nullable().default(null),
+    averageSpeedMps: z.number().nonnegative().nullable().default(null),
+    metadata: z.record(z.string(), z.unknown()).default({})
+});
+export const movementUserBoxCreateSchema = movementUserBoxSchemaBase.superRefine((value, ctx) => {
+    if (Date.parse(value.endedAt) <= Date.parse(value.startedAt)) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["endedAt"],
+            message: "Movement boxes must end after they start."
+        });
+    }
+});
+export const movementUserBoxPatchSchema = movementUserBoxSchemaBase.partial().superRefine((value, ctx) => {
+    if (value.startedAt && value.endedAt) {
+        if (Date.parse(value.endedAt) <= Date.parse(value.startedAt)) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ["endedAt"],
+                message: "Movement boxes must end after they start."
+            });
+        }
+    }
+});
+export const movementUserBoxPreflightSchema = movementUserBoxSchemaBase.extend({
+    excludeBoxId: z.string().trim().min(1).nullable().optional(),
+    rangeStart: z.string().datetime().nullable().optional(),
+    rangeEnd: z.string().datetime().nullable().optional()
+});
+export const movementAutomaticBoxInvalidateSchema = z.object({
+    startedAt: z.string().datetime().optional(),
+    endedAt: z.string().datetime().optional(),
+    title: z.string().trim().optional(),
+    subtitle: z.string().trim().optional(),
+    metadata: z.record(z.string(), z.unknown()).default({})
+});
 export const movementTripPointPatchSchema = z.object({
     recordedAt: z.string().datetime().optional(),
     latitude: z.number().finite().optional(),
@@ -294,12 +350,25 @@ export const movementMobileTimelineSchema = movementMobileBootstrapSchema.extend
 export const movementMobilePlaceMutationSchema = movementMobileBootstrapSchema.extend({
     place: movementPlaceMutationSchema.omit({ userId: true, source: true })
 });
+export const movementMobileUserBoxCreateSchema = movementMobileBootstrapSchema.extend({
+    box: movementUserBoxCreateSchema
+});
+export const movementMobileUserBoxPatchSchema = movementMobileBootstrapSchema.extend({
+    patch: movementUserBoxPatchSchema
+});
+export const movementMobileUserBoxPreflightSchema = movementMobileBootstrapSchema.extend({
+    draft: movementUserBoxPreflightSchema
+});
+export const movementMobileAutomaticBoxInvalidateSchema = movementMobileBootstrapSchema.extend({
+    invalidate: movementAutomaticBoxInvalidateSchema
+});
 export const movementMobileStayPatchSchema = movementMobileBootstrapSchema.extend({
     patch: movementStayPatchSchema
 });
 export const movementMobileTripPatchSchema = movementMobileBootstrapSchema.extend({
     patch: movementTripPatchSchema
 });
+const MISSING_MOVEMENT_DATA_THRESHOLD_SECONDS = 60 * 60;
 function nowIso() {
     return new Date().toISOString();
 }
@@ -398,6 +467,206 @@ function listMovementTripOverrides(userId) {
        WHERE user_id = ?`)
         .all(userId);
 }
+function listMovementBoxRows(input) {
+    const clauses = [];
+    const values = [];
+    if (input.userIds && input.userIds.length > 0) {
+        clauses.push(`user_id IN (${input.userIds.map(() => "?").join(",")})`);
+        values.push(...input.userIds);
+    }
+    if (input.sourceKinds && input.sourceKinds.length > 0) {
+        clauses.push(`source_kind IN (${input.sourceKinds.map(() => "?").join(",")})`);
+        values.push(...input.sourceKinds);
+    }
+    if (!input.includeDeleted) {
+        clauses.push(`deleted_at IS NULL`);
+    }
+    const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
+    return getDatabase()
+        .prepare(`SELECT *
+       FROM movement_boxes
+       ${where}
+       ORDER BY started_at ASC, ended_at ASC, created_at ASC`)
+        .all(...values);
+}
+function getMovementBoxRow(id) {
+    return getDatabase()
+        .prepare(`SELECT *
+       FROM movement_boxes
+       WHERE id = ?`)
+        .get(id);
+}
+function movementBoxTags(row) {
+    return uniqStrings(safeJsonParse(row.tags_json, []));
+}
+function movementBoxMetadata(row) {
+    return safeJsonParse(row.metadata_json, {});
+}
+function movementBoxRawStayIds(row) {
+    return safeJsonParse(row.raw_stay_ids_json, []);
+}
+function movementBoxRawTripIds(row) {
+    return safeJsonParse(row.raw_trip_ids_json, []);
+}
+function movementBoxOverriddenAutomaticBoxIds(row) {
+    return safeJsonParse(row.overridden_automatic_box_ids_json, []);
+}
+function movementBoxOverriddenUserBoxIds(row) {
+    return safeJsonParse(row.overridden_user_box_ids_json, []);
+}
+function movementBoxOverrideRanges(row) {
+    return safeJsonParse(row.override_ranges_json, []);
+}
+function normalizeMovementBoxTitle(row) {
+    const title = row.title.trim();
+    if (row.kind !== "missing") {
+        return title;
+    }
+    if (row.source_kind === "automatic") {
+        return "Missing data";
+    }
+    if (title.length === 0) {
+        return row.origin === "user_invalidated"
+            ? "User invalidated movement"
+            : "User-defined missing data";
+    }
+    const normalized = title.toLowerCase();
+    if (normalized === "stay" ||
+        normalized === "continued stay" ||
+        normalized === "repaired stay") {
+        return row.origin === "user_invalidated"
+            ? "User invalidated movement"
+            : "User-defined missing data";
+    }
+    return title;
+}
+function normalizeMovementBoxSubtitle(row) {
+    const subtitle = row.subtitle.trim();
+    if (row.kind !== "missing") {
+        return subtitle;
+    }
+    if (row.source_kind === "automatic") {
+        return "No trusted movement signal for this period.";
+    }
+    if (subtitle.length > 0) {
+        return subtitle;
+    }
+    return row.origin === "user_invalidated"
+        ? "Overrides the automatic movement box with missing data."
+        : "User-defined missing-data override.";
+}
+function mapMovementBoxRow(row) {
+    return {
+        id: row.id,
+        boxId: row.id,
+        kind: row.kind,
+        sourceKind: row.source_kind,
+        origin: row.origin,
+        editable: row.editable === 1,
+        startedAt: row.started_at,
+        endedAt: row.ended_at,
+        trueStartedAt: row.true_started_at ?? row.started_at,
+        trueEndedAt: row.true_ended_at ?? row.ended_at,
+        visibleStartedAt: row.started_at,
+        visibleEndedAt: row.ended_at,
+        durationSeconds: durationSeconds(row.started_at, row.ended_at),
+        title: normalizeMovementBoxTitle(row),
+        subtitle: normalizeMovementBoxSubtitle(row),
+        placeLabel: row.place_label,
+        anchorExternalUid: row.anchor_external_uid,
+        tags: movementBoxTags(row),
+        distanceMeters: row.distance_meters ?? 0,
+        averageSpeedMps: row.average_speed_mps ?? 0,
+        overrideCount: row.override_count,
+        overriddenAutomaticBoxIds: movementBoxOverriddenAutomaticBoxIds(row),
+        overriddenUserBoxIds: movementBoxOverriddenUserBoxIds(row),
+        isFullyHidden: row.is_fully_hidden === 1,
+        rawStayIds: movementBoxRawStayIds(row),
+        rawTripIds: movementBoxRawTripIds(row),
+        rawPointCount: row.raw_point_count,
+        hasLegacyCorrections: row.has_legacy_corrections === 1,
+        metadata: {
+            ...movementBoxMetadata(row),
+            overrideRanges: movementBoxOverrideRanges(row),
+            overriddenStartedAt: row.overridden_started_at,
+            overriddenEndedAt: row.overridden_ended_at,
+            overriddenByBoxId: row.overridden_by_box_id,
+            isOverridden: row.is_overridden === 1
+        },
+        createdAt: row.created_at,
+        updatedAt: row.updated_at
+    };
+}
+function insertMovementBox(input) {
+    const now = nowIso();
+    const existingByLegacyOriginKey = input.legacyOriginKey != null
+        ? (getDatabase()
+            .prepare(`SELECT id
+             FROM movement_boxes
+             WHERE user_id = ?
+               AND legacy_origin_key = ?`)
+            .get(input.userId, input.legacyOriginKey) ??
+            null)
+        : null;
+    const id = existingByLegacyOriginKey?.id ??
+        input.id ??
+        `mbx_${randomUUID().replaceAll("-", "").slice(0, 10)}`;
+    getDatabase()
+        .prepare(`INSERT INTO movement_boxes (
+         id, user_id, kind, source_kind, origin, started_at, ended_at, title, subtitle,
+         place_label, anchor_external_uid, tags_json, distance_meters, average_speed_mps,
+         editable, override_count, overridden_automatic_box_ids_json,
+         true_started_at, true_ended_at, overridden_started_at, overridden_ended_at,
+         overridden_by_box_id, overridden_user_box_ids_json, override_ranges_json,
+         is_overridden, is_fully_hidden, raw_stay_ids_json,
+         raw_trip_ids_json, raw_point_count, has_legacy_corrections, legacy_origin_key,
+         metadata_json, deleted_at, created_at, updated_at
+       )
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(id) DO UPDATE SET
+         kind = excluded.kind,
+         source_kind = excluded.source_kind,
+         origin = excluded.origin,
+         started_at = excluded.started_at,
+         ended_at = excluded.ended_at,
+         title = excluded.title,
+         subtitle = excluded.subtitle,
+         place_label = excluded.place_label,
+         anchor_external_uid = excluded.anchor_external_uid,
+         tags_json = excluded.tags_json,
+         distance_meters = excluded.distance_meters,
+         average_speed_mps = excluded.average_speed_mps,
+         editable = excluded.editable,
+         override_count = excluded.override_count,
+         overridden_automatic_box_ids_json = excluded.overridden_automatic_box_ids_json,
+         true_started_at = excluded.true_started_at,
+         true_ended_at = excluded.true_ended_at,
+         overridden_started_at = excluded.overridden_started_at,
+         overridden_ended_at = excluded.overridden_ended_at,
+         overridden_by_box_id = excluded.overridden_by_box_id,
+         overridden_user_box_ids_json = excluded.overridden_user_box_ids_json,
+         override_ranges_json = excluded.override_ranges_json,
+         is_overridden = excluded.is_overridden,
+         is_fully_hidden = excluded.is_fully_hidden,
+         raw_stay_ids_json = excluded.raw_stay_ids_json,
+         raw_trip_ids_json = excluded.raw_trip_ids_json,
+         raw_point_count = excluded.raw_point_count,
+         has_legacy_corrections = excluded.has_legacy_corrections,
+         legacy_origin_key = excluded.legacy_origin_key,
+         metadata_json = excluded.metadata_json,
+         deleted_at = excluded.deleted_at,
+         updated_at = excluded.updated_at`)
+        .run(id, input.userId, input.kind, input.sourceKind, input.origin, input.startedAt, input.endedAt, input.title ?? "", input.subtitle ?? "", input.placeLabel ?? null, input.anchorExternalUid ?? null, JSON.stringify(uniqStrings(input.tags ?? [])), input.distanceMeters ?? null, input.averageSpeedMps ?? null, input.editable ? 1 : 0, input.overrideCount ?? 0, JSON.stringify(input.overriddenAutomaticBoxIds ?? []), input.trueStartedAt ?? input.startedAt, input.trueEndedAt ?? input.endedAt, input.overriddenStartedAt ?? null, input.overriddenEndedAt ?? null, input.overriddenByBoxId ?? null, JSON.stringify(input.overriddenUserBoxIds ?? []), JSON.stringify(input.overrideRanges ?? []), input.isOverridden ? 1 : 0, input.isFullyHidden ? 1 : 0, JSON.stringify(input.rawStayIds ?? []), JSON.stringify(input.rawTripIds ?? []), input.rawPointCount ?? 0, input.hasLegacyCorrections ? 1 : 0, input.legacyOriginKey ?? null, JSON.stringify(input.metadata ?? {}), input.deletedAt ?? null, input.createdAt ?? now, input.updatedAt ?? now);
+    return getMovementBoxRow(id);
+}
+function softDeleteMovementBox(id) {
+    const now = nowIso();
+    getDatabase()
+        .prepare(`UPDATE movement_boxes
+       SET deleted_at = ?, updated_at = ?
+       WHERE id = ?`)
+        .run(now, now, id);
+}
 function applyMovementStaySyncDirectives(userId, stay) {
     const tombstoned = new Set(listMovementStayTombstones(userId).map((row) => row.stay_external_uid));
     if (tombstoned.has(stay.externalUid)) {
@@ -608,7 +877,9 @@ function decodeMovementTimelineCursor(rawValue) {
             typeof parsed.endedAt !== "string") {
             return null;
         }
-        if (parsed.kind !== "stay" && parsed.kind !== "trip") {
+        if (parsed.kind !== "stay" &&
+            parsed.kind !== "trip" &&
+            parsed.kind !== "missing") {
             return null;
         }
         return parsed;
@@ -842,6 +1113,16 @@ function mapMovementTrip(row, placesById, points = [], stops = []) {
             : null
     };
 }
+function enrichMovementSegmentWithScreenTime(segment, userIds) {
+    return {
+        ...segment,
+        ...getScreenTimeOverlapSummary({
+            startedAt: segment.startedAt,
+            endedAt: segment.endedAt,
+            userIds
+        })
+    };
+}
 function getMovementSettingsRow(userId) {
     return getDatabase()
         .prepare(`SELECT *
@@ -1688,6 +1969,7 @@ export function ingestMovementSync(pairing, payload) {
         }
     });
     cleanupRawTripPoints(pairing.user_id);
+    rebuildAutomaticMovementBoxes(pairing.user_id);
     recordActivityEvent({
         entityType: "system",
         entityId: pairing.id,
@@ -1821,25 +2103,687 @@ function compareMovementTimelineDescending(left, right) {
         right.kind.localeCompare(left.kind) ||
         right.id.localeCompare(left.id));
 }
-export function getMovementTimeline(input) {
-    const parsed = movementTimelineQuerySchema.parse(input);
-    const userIds = parsed.userIds.length > 0 ? parsed.userIds : undefined;
-    const initialStayRows = listMovementStayRows(userIds);
-    const initialTripRows = listMovementTripRows(userIds);
-    const scopedUserIds = new Set();
-    for (const row of initialStayRows) {
-        scopedUserIds.add(row.user_id);
+function movementBoundaryDistanceMeters(left, right) {
+    if (!left || !right) {
+        return null;
     }
-    for (const row of initialTripRows) {
-        scopedUserIds.add(row.user_id);
+    return haversineDistanceMeters({
+        latitude: left.latitude,
+        longitude: left.longitude
+    }, {
+        latitude: right.latitude,
+        longitude: right.longitude
+    });
+}
+function movementBoundariesShareAnchor(left, right) {
+    if (!left || !right) {
+        return false;
     }
-    for (const scopedUserId of scopedUserIds) {
-        reconcileMovementOverlapValidation(scopedUserId);
+    if (left.placeExternalUid &&
+        right.placeExternalUid &&
+        left.placeExternalUid === right.placeExternalUid) {
+        return true;
     }
-    const places = listMovementPlaceRows(userIds).map(mapMovementPlace);
-    const placesById = new Map(places.map((place) => [place.id, place]));
-    const stayRows = listMovementStayRows(userIds);
-    const tripRows = listMovementTripRows(userIds);
+    const displacementMeters = movementBoundaryDistanceMeters(left, right);
+    return displacementMeters !== null && displacementMeters <= 100;
+}
+function buildDerivedMovementGapSegment(input) {
+    return {
+        id: input.id,
+        kind: input.kind,
+        origin: input.origin,
+        startedAt: input.startedAt,
+        endedAt: input.endedAt,
+        durationSeconds: durationSeconds(input.startedAt, input.endedAt),
+        displacementMeters: input.displacementMeters ?? null,
+        placeLabel: input.placeLabel ?? null,
+        suppressedShortJump: input.suppressedShortJump ?? false,
+        startBoundary: input.startBoundary ?? null,
+        endBoundary: input.endBoundary ?? null
+    };
+}
+function coalesceMovementStayCoverageSegments(segments) {
+    const coalesced = [];
+    for (const segment of segments) {
+        const previous = coalesced[coalesced.length - 1];
+        const shouldMerge = previous &&
+            previous.kind === "stay" &&
+            segment.kind === "stay" &&
+            (previous.origin !== "recorded" || segment.origin !== "recorded") &&
+            durationSeconds(previous.endedAt, segment.startedAt) === 0 &&
+            movementBoundariesShareAnchor(previous.endBoundary, segment.startBoundary);
+        if (!shouldMerge || !previous) {
+            coalesced.push(segment);
+            continue;
+        }
+        const mergedOrigin = previous.origin === "continued_stay" || segment.origin === "continued_stay"
+            ? "continued_stay"
+            : previous.origin === "repaired_gap" || segment.origin === "repaired_gap"
+                ? "repaired_gap"
+                : "recorded";
+        coalesced[coalesced.length - 1] = {
+            id: `coalesced_stay_${previous.id}_${segment.id}`,
+            kind: "stay",
+            origin: mergedOrigin,
+            startedAt: previous.startedAt,
+            endedAt: segment.endedAt,
+            durationSeconds: durationSeconds(previous.startedAt, segment.endedAt),
+            payload: null,
+            displacementMeters: null,
+            placeLabel: previous.placeLabel ??
+                segment.placeLabel ??
+                previous.endBoundary?.placeLabel ??
+                segment.startBoundary?.placeLabel ??
+                null,
+            suppressedShortJump: previous.suppressedShortJump || segment.suppressedShortJump,
+            startBoundary: previous.startBoundary,
+            endBoundary: segment.endBoundary
+        };
+    }
+    return coalesced;
+}
+// Movement repair rules are intentionally duplicated here and in the companion.
+// They are binding, and the tests are expected to enforce them:
+// 1. Every positive-duration interval must be labeled as stay, trip, or missing.
+// 2. Missing is never allowed for gaps under one hour.
+// 3. Any move with cumulative distance under 100m is invalid and must be repaired into stay.
+// 4. Any move with duration under 5 minutes is invalid and must be repaired into stay.
+// 5. For gaps under one hour:
+//    - same place / same anchor => continue stay
+//    - different place => repaired trip only when boundary displacement is >100m
+//      and the gap lasts at least 5 minutes
+//    - otherwise => repaired stay
+function normalizeMovementCoverageSegments(segments, options = {}) {
+    const sorted = [...segments]
+        .sort((left, right) => left.startedAt.localeCompare(right.startedAt) ||
+        left.endedAt.localeCompare(right.endedAt))
+        .map((segment) => ({
+        id: segment.id,
+        kind: segment.kind,
+        origin: "recorded",
+        startedAt: segment.startedAt,
+        endedAt: segment.endedAt,
+        durationSeconds: durationSeconds(segment.startedAt, segment.endedAt),
+        payload: segment.payload,
+        displacementMeters: null,
+        placeLabel: segment.kind === "stay"
+            ? segment.startBoundary?.placeLabel ?? segment.endBoundary?.placeLabel ?? null
+            : segment.endBoundary?.placeLabel ?? segment.startBoundary?.placeLabel ?? null,
+        suppressedShortJump: false,
+        startBoundary: segment.startBoundary,
+        endBoundary: segment.endBoundary
+    }));
+    const classifyGap = (previous, next) => {
+        const gapSeconds = durationSeconds(previous.endedAt, next.startedAt);
+        if (gapSeconds <= 0) {
+            return null;
+        }
+        if (gapSeconds > MISSING_MOVEMENT_DATA_THRESHOLD_SECONDS) {
+            return buildDerivedMovementGapSegment({
+                id: `missing_${previous.endedAt}_${next.startedAt}`,
+                kind: "missing",
+                origin: "missing",
+                startedAt: previous.endedAt,
+                endedAt: next.startedAt
+            });
+        }
+        if (movementBoundariesShareAnchor(previous.endBoundary, next.startBoundary)) {
+            return buildDerivedMovementGapSegment({
+                id: `continued_stay_${previous.id}_${next.id}`,
+                kind: "stay",
+                origin: "repaired_gap",
+                startedAt: previous.endedAt,
+                endedAt: next.startedAt,
+                displacementMeters: movementBoundaryDistanceMeters(previous.endBoundary, next.startBoundary) ?? 0,
+                placeLabel: previous.endBoundary?.placeLabel ?? next.startBoundary?.placeLabel ?? null,
+                startBoundary: previous.endBoundary,
+                endBoundary: next.startBoundary
+            });
+        }
+        const displacementMeters = movementBoundaryDistanceMeters(previous.endBoundary, next.startBoundary);
+        if (gapSeconds < 5 * 60) {
+            return buildDerivedMovementGapSegment({
+                id: `repaired_stay_short_jump_${previous.id}_${next.id}`,
+                kind: "stay",
+                origin: "repaired_gap",
+                startedAt: previous.endedAt,
+                endedAt: next.startedAt,
+                displacementMeters,
+                placeLabel: previous.endBoundary?.placeLabel ?? next.startBoundary?.placeLabel ?? null,
+                suppressedShortJump: true,
+                startBoundary: previous.endBoundary,
+                endBoundary: next.startBoundary
+            });
+        }
+        if (displacementMeters === null || displacementMeters <= 100) {
+            return buildDerivedMovementGapSegment({
+                id: `repaired_stay_short_distance_${previous.id}_${next.id}`,
+                kind: "stay",
+                origin: "repaired_gap",
+                startedAt: previous.endedAt,
+                endedAt: next.startedAt,
+                displacementMeters: displacementMeters ?? null,
+                placeLabel: previous.endBoundary?.placeLabel ?? next.startBoundary?.placeLabel ?? null,
+                startBoundary: previous.endBoundary,
+                endBoundary: next.startBoundary
+            });
+        }
+        return buildDerivedMovementGapSegment({
+            id: `repaired_trip_${previous.id}_${next.id}`,
+            kind: "trip",
+            origin: "repaired_gap",
+            startedAt: previous.endedAt,
+            endedAt: next.startedAt,
+            displacementMeters,
+            placeLabel: next.startBoundary?.placeLabel ?? previous.endBoundary?.placeLabel ?? null,
+            startBoundary: previous.endBoundary,
+            endBoundary: next.startBoundary
+        });
+    };
+    const coverage = [];
+    if (sorted.length === 0 && options.rangeStart && options.rangeEnd) {
+        const uncoveredSeconds = durationSeconds(options.rangeStart, options.rangeEnd);
+        return [
+            uncoveredSeconds > MISSING_MOVEMENT_DATA_THRESHOLD_SECONDS
+                ? buildDerivedMovementGapSegment({
+                    id: `missing_${options.rangeStart}_${options.rangeEnd}`,
+                    kind: "missing",
+                    origin: "missing",
+                    startedAt: options.rangeStart,
+                    endedAt: options.rangeEnd
+                })
+                : buildDerivedMovementGapSegment({
+                    id: `empty_stay_${options.rangeStart}_${options.rangeEnd}`,
+                    kind: "stay",
+                    origin: "repaired_gap",
+                    startedAt: options.rangeStart,
+                    endedAt: options.rangeEnd
+                })
+        ];
+    }
+    if (options.rangeStart && sorted[0]) {
+        const first = sorted[0];
+        const leadingGapSeconds = durationSeconds(options.rangeStart, first.startedAt);
+        if (leadingGapSeconds > 0) {
+            coverage.push(leadingGapSeconds > MISSING_MOVEMENT_DATA_THRESHOLD_SECONDS
+                ? buildDerivedMovementGapSegment({
+                    id: `missing_${options.rangeStart}_${first.startedAt}`,
+                    kind: "missing",
+                    origin: "missing",
+                    startedAt: options.rangeStart,
+                    endedAt: first.startedAt,
+                    placeLabel: first.startBoundary?.placeLabel ?? null,
+                    endBoundary: first.startBoundary
+                })
+                : buildDerivedMovementGapSegment({
+                    id: `leading_stay_${options.rangeStart}_${first.id}`,
+                    kind: "stay",
+                    origin: "repaired_gap",
+                    startedAt: options.rangeStart,
+                    endedAt: first.startedAt,
+                    placeLabel: first.startBoundary?.placeLabel ?? null,
+                    endBoundary: first.startBoundary
+                }));
+        }
+    }
+    for (const [index, segment] of sorted.entries()) {
+        if (index > 0) {
+            const derivedGap = classifyGap(sorted[index - 1], segment);
+            if (derivedGap) {
+                coverage.push(derivedGap);
+            }
+        }
+        coverage.push(segment);
+    }
+    if (options.rangeEnd && sorted.length > 0) {
+        const last = sorted[sorted.length - 1];
+        const trailingGapSeconds = durationSeconds(last.endedAt, options.rangeEnd);
+        if (trailingGapSeconds > 0) {
+            if (trailingGapSeconds <= MISSING_MOVEMENT_DATA_THRESHOLD_SECONDS) {
+                coverage.push(buildDerivedMovementGapSegment({
+                    id: `continued_stay_${last.id}_${options.rangeEnd}`,
+                    kind: "stay",
+                    origin: last.kind === "stay" ? "continued_stay" : "repaired_gap",
+                    startedAt: last.endedAt,
+                    endedAt: options.rangeEnd,
+                    displacementMeters: 0,
+                    placeLabel: last.endBoundary?.placeLabel ?? null,
+                    startBoundary: last.endBoundary,
+                    endBoundary: last.endBoundary
+                }));
+            }
+            else {
+                coverage.push(buildDerivedMovementGapSegment({
+                    id: `missing_${last.endedAt}_${options.rangeEnd}`,
+                    kind: "missing",
+                    origin: "missing",
+                    startedAt: last.endedAt,
+                    endedAt: options.rangeEnd,
+                    placeLabel: last.endBoundary?.placeLabel ?? null,
+                    startBoundary: last.endBoundary
+                }));
+            }
+        }
+    }
+    return options.allowStayCoalescing === false
+        ? coverage
+        : coalesceMovementStayCoverageSegments(coverage);
+}
+function projectedBoundariesShareAnchor(left, right) {
+    if (!left || !right) {
+        return false;
+    }
+    if (left.placeExternalUid &&
+        right.placeExternalUid &&
+        left.placeExternalUid === right.placeExternalUid) {
+        return true;
+    }
+    if (left.placeLabel &&
+        right.placeLabel &&
+        left.placeLabel.trim().length > 0 &&
+        left.placeLabel === right.placeLabel) {
+        return true;
+    }
+    if (left.latitude == null ||
+        left.longitude == null ||
+        right.latitude == null ||
+        right.longitude == null) {
+        return false;
+    }
+    return (haversineDistanceMeters({ latitude: left.latitude, longitude: left.longitude }, { latitude: right.latitude, longitude: right.longitude }) <= 100);
+}
+function projectedBoundaryDistanceMeters(left, right) {
+    if (!left || !right) {
+        return null;
+    }
+    if (left.latitude == null ||
+        left.longitude == null ||
+        right.latitude == null ||
+        right.longitude == null) {
+        return null;
+    }
+    return haversineDistanceMeters({ latitude: left.latitude, longitude: left.longitude }, { latitude: right.latitude, longitude: right.longitude });
+}
+function mergeProjectedBoxArrays(left, right) {
+    return uniqStrings([...left, ...right]);
+}
+function ensureProjectedMovementBoxCoverage(segments, options) {
+    const sorted = [...segments].sort((left, right) => left.startedAt.localeCompare(right.startedAt) ||
+        left.endedAt.localeCompare(right.endedAt) ||
+        left.kind.localeCompare(right.kind) ||
+        left.id.localeCompare(right.id));
+    const deriveGapSegment = (startedAt, endedAt, previous, next) => {
+        const gapSeconds = durationSeconds(startedAt, endedAt);
+        if (gapSeconds <= 0) {
+            return null;
+        }
+        const previousBoundary = previous
+            ? options.resolveBoundary(previous, "end")
+            : null;
+        const nextBoundary = next ? options.resolveBoundary(next, "start") : null;
+        if (gapSeconds > MISSING_MOVEMENT_DATA_THRESHOLD_SECONDS) {
+            return {
+                id: `projected_missing_${startedAt}_${endedAt}`,
+                boxId: `projected_missing_${startedAt}_${endedAt}`,
+                kind: "missing",
+                sourceKind: "automatic",
+                origin: "missing",
+                editable: false,
+                startedAt,
+                endedAt,
+                trueStartedAt: startedAt,
+                trueEndedAt: endedAt,
+                visibleStartedAt: startedAt,
+                visibleEndedAt: endedAt,
+                durationSeconds: gapSeconds,
+                title: "Missing data",
+                subtitle: "No trusted movement signal for this period.",
+                placeLabel: previousBoundary?.placeLabel ?? nextBoundary?.placeLabel ?? null,
+                tags: ["missing-data"],
+                distanceMeters: null,
+                averageSpeedMps: null,
+                overrideCount: 0,
+                overriddenAutomaticBoxIds: [],
+                overriddenUserBoxIds: [],
+                isFullyHidden: false,
+                rawStayIds: [],
+                rawTripIds: [],
+                rawPointCount: 0,
+                hasLegacyCorrections: false,
+                metadata: { syncSource: "automatic" }
+            };
+        }
+        if (projectedBoundariesShareAnchor(previousBoundary, nextBoundary)) {
+            return {
+                id: `projected_continued_stay_${startedAt}_${endedAt}`,
+                boxId: `projected_continued_stay_${startedAt}_${endedAt}`,
+                kind: "stay",
+                sourceKind: "automatic",
+                origin: previous?.kind === "stay" || next?.kind === "stay"
+                    ? "continued_stay"
+                    : "repaired_gap",
+                editable: false,
+                startedAt,
+                endedAt,
+                trueStartedAt: startedAt,
+                trueEndedAt: endedAt,
+                visibleStartedAt: startedAt,
+                visibleEndedAt: endedAt,
+                durationSeconds: gapSeconds,
+                title: previousBoundary?.placeLabel ??
+                    nextBoundary?.placeLabel ??
+                    "Continued stay",
+                subtitle: "Short stationary gap carried forward into one continuous stay.",
+                placeLabel: previousBoundary?.placeLabel ?? nextBoundary?.placeLabel ?? null,
+                tags: ["continued_stay"],
+                distanceMeters: null,
+                averageSpeedMps: null,
+                overrideCount: 0,
+                overriddenAutomaticBoxIds: [],
+                overriddenUserBoxIds: [],
+                isFullyHidden: false,
+                rawStayIds: [],
+                rawTripIds: [],
+                rawPointCount: 0,
+                hasLegacyCorrections: false,
+                metadata: { syncSource: "automatic" }
+            };
+        }
+        const displacementMeters = projectedBoundaryDistanceMeters(previousBoundary, nextBoundary);
+        if (gapSeconds < 5 * 60 || displacementMeters == null || displacementMeters <= 100) {
+            return {
+                id: `projected_repaired_stay_${startedAt}_${endedAt}`,
+                boxId: `projected_repaired_stay_${startedAt}_${endedAt}`,
+                kind: "stay",
+                sourceKind: "automatic",
+                origin: "repaired_gap",
+                editable: false,
+                startedAt,
+                endedAt,
+                trueStartedAt: startedAt,
+                trueEndedAt: endedAt,
+                visibleStartedAt: startedAt,
+                visibleEndedAt: endedAt,
+                durationSeconds: gapSeconds,
+                title: previousBoundary?.placeLabel ??
+                    nextBoundary?.placeLabel ??
+                    "Repaired stay",
+                subtitle: gapSeconds < 5 * 60
+                    ? "Short jump under five minutes suppressed into stay continuity."
+                    : "Short gap repaired as a stay between known anchors.",
+                placeLabel: previousBoundary?.placeLabel ?? nextBoundary?.placeLabel ?? null,
+                tags: gapSeconds < 5 * 60
+                    ? ["repaired_gap", "suppressed-short-jump"]
+                    : ["repaired_gap"],
+                distanceMeters: null,
+                averageSpeedMps: null,
+                overrideCount: 0,
+                overriddenAutomaticBoxIds: [],
+                overriddenUserBoxIds: [],
+                isFullyHidden: false,
+                rawStayIds: [],
+                rawTripIds: [],
+                rawPointCount: 0,
+                hasLegacyCorrections: false,
+                metadata: { syncSource: "automatic" }
+            };
+        }
+        return {
+            id: `projected_repaired_trip_${startedAt}_${endedAt}`,
+            boxId: `projected_repaired_trip_${startedAt}_${endedAt}`,
+            kind: "trip",
+            sourceKind: "automatic",
+            origin: "repaired_gap",
+            editable: false,
+            startedAt,
+            endedAt,
+            trueStartedAt: startedAt,
+            trueEndedAt: endedAt,
+            visibleStartedAt: startedAt,
+            visibleEndedAt: endedAt,
+            durationSeconds: gapSeconds,
+            title: nextBoundary?.placeLabel ??
+                previousBoundary?.placeLabel ??
+                "Repaired move",
+            subtitle: "Short gap repaired as a move between known anchors.",
+            placeLabel: nextBoundary?.placeLabel ?? previousBoundary?.placeLabel ?? null,
+            tags: ["repaired_gap"],
+            distanceMeters: displacementMeters,
+            averageSpeedMps: displacementMeters / Math.max(1, gapSeconds),
+            overrideCount: 0,
+            overriddenAutomaticBoxIds: [],
+            overriddenUserBoxIds: [],
+            isFullyHidden: false,
+            rawStayIds: [],
+            rawTripIds: [],
+            rawPointCount: 0,
+            hasLegacyCorrections: false,
+            metadata: { syncSource: "automatic" }
+        };
+    };
+    const withCoverage = [];
+    if (options.rangeStart) {
+        const first = sorted[0] ?? null;
+        const leading = deriveGapSegment(options.rangeStart, first?.startedAt ?? options.rangeEnd ?? options.rangeStart, null, first);
+        if (leading) {
+            withCoverage.push(leading);
+        }
+    }
+    for (const [index, segment] of sorted.entries()) {
+        if (index > 0) {
+            const previous = sorted[index - 1];
+            const derived = deriveGapSegment(previous.endedAt, segment.startedAt, previous, segment);
+            if (derived) {
+                withCoverage.push(derived);
+            }
+        }
+        withCoverage.push(segment);
+    }
+    if (options.rangeEnd) {
+        const last = sorted[sorted.length - 1] ?? null;
+        const trailing = deriveGapSegment(last?.endedAt ?? options.rangeStart ?? options.rangeEnd, options.rangeEnd, last, null);
+        if (trailing) {
+            withCoverage.push(trailing);
+        }
+    }
+    const coalesced = [];
+    for (const segment of withCoverage) {
+        const previous = coalesced[coalesced.length - 1];
+        const shouldMerge = previous &&
+            previous.kind === "stay" &&
+            segment.kind === "stay" &&
+            previous.sourceKind === "automatic" &&
+            segment.sourceKind === "automatic" &&
+            previous.endedAt === segment.startedAt &&
+            projectedBoundariesShareAnchor(options.resolveBoundary(previous, "end"), options.resolveBoundary(segment, "start"));
+        if (!shouldMerge || !previous) {
+            coalesced.push(segment);
+            continue;
+        }
+        coalesced[coalesced.length - 1] = {
+            ...previous,
+            id: `projected_coalesced_${previous.id}_${segment.id}`,
+            boxId: previous.boxId,
+            origin: previous.origin === "continued_stay" || segment.origin === "continued_stay"
+                ? "continued_stay"
+                : previous.origin === "repaired_gap" || segment.origin === "repaired_gap"
+                    ? "repaired_gap"
+                    : previous.origin,
+            endedAt: segment.endedAt,
+            visibleEndedAt: segment.endedAt,
+            durationSeconds: durationSeconds(previous.startedAt, segment.endedAt),
+            title: previous.title || segment.title,
+            subtitle: previous.origin === "continued_stay" || segment.origin === "continued_stay"
+                ? "Short stationary gap carried forward into one continuous stay."
+                : previous.subtitle,
+            placeLabel: previous.placeLabel ?? segment.placeLabel ?? null,
+            tags: mergeProjectedBoxArrays(previous.tags, segment.tags),
+            overrideCount: previous.overrideCount + segment.overrideCount,
+            overriddenAutomaticBoxIds: mergeProjectedBoxArrays(previous.overriddenAutomaticBoxIds, segment.overriddenAutomaticBoxIds),
+            overriddenUserBoxIds: mergeProjectedBoxArrays(previous.overriddenUserBoxIds, segment.overriddenUserBoxIds),
+            isFullyHidden: false,
+            rawStayIds: mergeProjectedBoxArrays(previous.rawStayIds, segment.rawStayIds),
+            rawTripIds: mergeProjectedBoxArrays(previous.rawTripIds, segment.rawTripIds),
+            rawPointCount: previous.rawPointCount + segment.rawPointCount,
+            hasLegacyCorrections: previous.hasLegacyCorrections || segment.hasLegacyCorrections,
+            metadata: {
+                ...previous.metadata,
+                coalescedSegmentIds: [
+                    ...(Array.isArray(previous.metadata.coalescedSegmentIds)
+                        ? previous.metadata.coalescedSegmentIds
+                        : [previous.id]),
+                    ...(Array.isArray(segment.metadata.coalescedSegmentIds)
+                        ? segment.metadata.coalescedSegmentIds
+                        : [segment.id])
+                ]
+            }
+        };
+    }
+    return coalesced.sort((left, right) => left.startedAt.localeCompare(right.startedAt) ||
+        left.endedAt.localeCompare(right.endedAt) ||
+        left.kind.localeCompare(right.kind) ||
+        left.id.localeCompare(right.id));
+}
+function movementBoxOverlapsRange(row, startedAt, endedAt) {
+    const rowStartedAt = row.true_started_at ?? row.started_at;
+    const rowEndedAt = row.true_ended_at ?? row.ended_at;
+    return rowStartedAt < endedAt && rowEndedAt > startedAt;
+}
+function mergeMovementOverrideRanges(ranges) {
+    const sorted = [...ranges]
+        .filter((range) => range.startedAt < range.endedAt)
+        .sort((left, right) => left.startedAt.localeCompare(right.startedAt) ||
+        left.endedAt.localeCompare(right.endedAt));
+    const merged = [];
+    for (const range of sorted) {
+        const previous = merged[merged.length - 1];
+        if (!previous || range.startedAt > previous.endedAt) {
+            merged.push({ ...range });
+            continue;
+        }
+        previous.endedAt =
+            range.endedAt > previous.endedAt ? range.endedAt : previous.endedAt;
+    }
+    return merged;
+}
+function subtractMovementOverrideRanges(startedAt, endedAt, ranges) {
+    let fragments = [{ startedAt, endedAt }];
+    for (const range of mergeMovementOverrideRanges(ranges)) {
+        fragments = fragments.flatMap((fragment) => {
+            if (range.startedAt >= fragment.endedAt || range.endedAt <= fragment.startedAt) {
+                return [fragment];
+            }
+            const nextFragments = [];
+            if (fragment.startedAt < range.startedAt) {
+                nextFragments.push({
+                    startedAt: fragment.startedAt,
+                    endedAt: range.startedAt
+                });
+            }
+            if (fragment.endedAt > range.endedAt) {
+                nextFragments.push({
+                    startedAt: range.endedAt,
+                    endedAt: fragment.endedAt
+                });
+            }
+            return nextFragments;
+        });
+    }
+    return fragments.filter((fragment) => fragment.startedAt < fragment.endedAt);
+}
+function updateMovementBoxOverrideState(id, input) {
+    getDatabase()
+        .prepare(`UPDATE movement_boxes
+       SET override_count = ?,
+           overridden_automatic_box_ids_json = ?,
+           true_started_at = ?,
+           true_ended_at = ?,
+           overridden_started_at = ?,
+           overridden_ended_at = ?,
+           overridden_by_box_id = ?,
+           overridden_user_box_ids_json = ?,
+           override_ranges_json = ?,
+           is_overridden = ?,
+           is_fully_hidden = ?,
+           updated_at = ?
+       WHERE id = ?`)
+        .run(input.overrideCount, JSON.stringify(input.overriddenAutomaticBoxIds), input.trueStartedAt, input.trueEndedAt, input.overriddenStartedAt, input.overriddenEndedAt, input.overriddenByBoxId, JSON.stringify(input.overriddenUserBoxIds), JSON.stringify(input.overrideRanges), input.isOverridden ? 1 : 0, input.isFullyHidden ? 1 : 0, nowIso(), id);
+}
+function recomputeMovementBoxOverrideState(userId) {
+    const rows = listMovementBoxRows({ userIds: [userId] });
+    const automaticRows = rows.filter((row) => row.source_kind === "automatic");
+    const userRows = rows.filter((row) => row.source_kind === "user_defined");
+    const orderedUserRows = [...userRows].sort((left, right) => right.updated_at.localeCompare(left.updated_at) ||
+        right.created_at.localeCompare(left.created_at) ||
+        right.id.localeCompare(left.id));
+    const newerRows = [];
+    for (const row of automaticRows) {
+        updateMovementBoxOverrideState(row.id, {
+            overrideCount: 0,
+            overriddenAutomaticBoxIds: [],
+            overriddenUserBoxIds: [],
+            trueStartedAt: row.started_at,
+            trueEndedAt: row.ended_at,
+            overriddenStartedAt: null,
+            overriddenEndedAt: null,
+            overriddenByBoxId: null,
+            overrideRanges: [],
+            isOverridden: false,
+            isFullyHidden: false
+        });
+    }
+    for (const row of orderedUserRows) {
+        const trueStartedAt = row.started_at;
+        const trueEndedAt = row.ended_at;
+        const overlappingAutomaticBoxIds = automaticRows
+            .filter((automatic) => movementBoxOverlapsRange(automatic, trueStartedAt, trueEndedAt))
+            .map((automatic) => automatic.id);
+        const overridingRows = newerRows.filter((candidate) => movementBoxOverlapsRange(candidate, trueStartedAt, trueEndedAt));
+        const overrideRanges = mergeMovementOverrideRanges(overridingRows.map((candidate) => ({
+            startedAt: (candidate.true_started_at ?? candidate.started_at) > trueStartedAt
+                ? (candidate.true_started_at ?? candidate.started_at)
+                : trueStartedAt,
+            endedAt: (candidate.true_ended_at ?? candidate.ended_at) < trueEndedAt
+                ? (candidate.true_ended_at ?? candidate.ended_at)
+                : trueEndedAt
+        })));
+        const visibleFragments = subtractMovementOverrideRanges(trueStartedAt, trueEndedAt, overrideRanges);
+        updateMovementBoxOverrideState(row.id, {
+            overrideCount: overlappingAutomaticBoxIds.length + overridingRows.length,
+            overriddenAutomaticBoxIds: overlappingAutomaticBoxIds,
+            overriddenUserBoxIds: overridingRows.map((candidate) => candidate.id),
+            trueStartedAt,
+            trueEndedAt,
+            overriddenStartedAt: overrideRanges[0]?.startedAt ?? null,
+            overriddenEndedAt: overrideRanges.length > 0
+                ? overrideRanges[overrideRanges.length - 1].endedAt
+                : null,
+            overriddenByBoxId: overridingRows[0]?.id ?? null,
+            overrideRanges,
+            isOverridden: overrideRanges.length > 0,
+            isFullyHidden: visibleFragments.length === 0
+        });
+        newerRows.push(row);
+    }
+}
+function legacyTripHasCorrections(userId, tripExternalUid) {
+    return (listMovementTripTombstones(userId).some((row) => row.trip_external_uid === tripExternalUid) ||
+        listMovementTripOverrides(userId).some((row) => row.trip_external_uid === tripExternalUid) ||
+        listMovementTripPointTombstones(userId, tripExternalUid).length > 0 ||
+        listMovementTripPointOverrides(userId, tripExternalUid).length > 0);
+}
+function legacyStayHasCorrections(userId, stayExternalUid) {
+    return (listMovementStayTombstones(userId).some((row) => row.stay_external_uid === stayExternalUid) ||
+        listMovementStayOverrides(userId).some((row) => row.stay_external_uid === stayExternalUid));
+}
+function migrateLegacyMovementCorrectionsToUserBoxes(userId) {
+    const placeRows = listMovementPlaceRows([userId]);
+    const placesById = new Map(placeRows.map((row) => {
+        const mapped = mapMovementPlace(row);
+        return [mapped.id, mapped];
+    }));
+    const stayRows = listMovementStayRows([userId]);
+    const tripRows = listMovementTripRows([userId]);
     const tripIds = tripRows.map((row) => row.id);
     const pointsByTrip = new Map();
     listTripPoints(tripIds).forEach((point) => {
@@ -1849,46 +2793,704 @@ export function getMovementTimeline(input) {
     listTripStops(tripIds).forEach((stop) => {
         stopsByTrip.set(stop.trip_id, [...(stopsByTrip.get(stop.trip_id) ?? []), stop]);
     });
-    const chronological = [
-        ...stayRows.map((row) => ({
-            id: row.id,
+    const stayByExternalUid = new Map(stayRows.map((row) => [row.external_uid, row]));
+    const tripByExternalUid = new Map(tripRows.map((row) => [row.external_uid, row]));
+    for (const row of listMovementStayTombstones(userId)) {
+        const stayRow = stayByExternalUid.get(row.stay_external_uid);
+        if (!stayRow) {
+            continue;
+        }
+        const stay = mapMovementStay(stayRow, placesById);
+        insertMovementBox({
+            userId,
+            kind: "missing",
+            sourceKind: "user_defined",
+            origin: "user_invalidated",
+            startedAt: stay.startedAt,
+            endedAt: stay.endedAt,
+            title: "User invalidated stay",
+            subtitle: `Replaces ${stay.place?.label ?? stay.label ?? "the automatic stay"} with missing data.`,
+            editable: true,
+            tags: ["user-invalidated", "legacy-migration"],
+            legacyOriginKey: `stay-tombstone:${row.stay_external_uid}`,
+            metadata: {
+                migratedFrom: "movement_stay_tombstones",
+                stayExternalUid: row.stay_external_uid
+            }
+        });
+    }
+    for (const row of listMovementTripTombstones(userId)) {
+        const tripRow = tripByExternalUid.get(row.trip_external_uid);
+        if (!tripRow) {
+            continue;
+        }
+        const trip = mapMovementTrip(tripRow, placesById, pointsByTrip.get(tripRow.id) ?? [], stopsByTrip.get(tripRow.id) ?? []);
+        insertMovementBox({
+            userId,
+            kind: "missing",
+            sourceKind: "user_defined",
+            origin: "user_invalidated",
+            startedAt: trip.startedAt,
+            endedAt: trip.endedAt,
+            title: "User invalidated move",
+            subtitle: `Replaces ${trip.label || "the automatic move"} with missing data.`,
+            editable: true,
+            tags: ["user-invalidated", "legacy-migration"],
+            legacyOriginKey: `trip-tombstone:${row.trip_external_uid}`,
+            metadata: {
+                migratedFrom: "movement_trip_tombstones",
+                tripExternalUid: row.trip_external_uid
+            }
+        });
+    }
+    for (const row of listMovementStayOverrides(userId)) {
+        const stayRow = stayByExternalUid.get(row.stay_external_uid);
+        if (!stayRow) {
+            continue;
+        }
+        const stay = mapMovementStay(stayRow, placesById);
+        const patch = safeJsonParse(row.stay_json, {});
+        insertMovementBox({
+            userId,
             kind: "stay",
-            startedAt: row.started_at,
-            endedAt: row.ended_at,
-            stay: mapMovementStay(row, placesById)
-        })),
-        ...tripRows.map((row) => ({
-            id: row.id,
+            sourceKind: "user_defined",
+            origin: "user_defined",
+            startedAt: patch.startedAt ?? stay.startedAt,
+            endedAt: patch.endedAt ?? stay.endedAt,
+            title: patch.placeLabel ?? patch.label ?? stay.place?.label ?? stay.label ?? "Manual stay",
+            subtitle: "Migrated user-defined stay correction.",
+            placeLabel: patch.placeLabel ?? stay.place?.label ?? stay.label ?? null,
+            anchorExternalUid: patch.placeExternalUid ?? stay.place?.externalUid ?? null,
+            tags: patch.tags ?? stay.tags,
+            editable: true,
+            legacyOriginKey: `stay-override:${row.stay_external_uid}`,
+            metadata: {
+                migratedFrom: "movement_stay_overrides",
+                stayExternalUid: row.stay_external_uid
+            }
+        });
+    }
+    for (const row of listMovementTripOverrides(userId)) {
+        const tripRow = tripByExternalUid.get(row.trip_external_uid);
+        if (!tripRow) {
+            continue;
+        }
+        const trip = mapMovementTrip(tripRow, placesById, pointsByTrip.get(tripRow.id) ?? [], stopsByTrip.get(tripRow.id) ?? []);
+        const patch = safeJsonParse(row.trip_json, {});
+        insertMovementBox({
+            userId,
             kind: "trip",
-            startedAt: row.started_at,
-            endedAt: row.ended_at,
-            trip: mapMovementTrip(row, placesById, pointsByTrip.get(row.id) ?? [], stopsByTrip.get(row.id) ?? [])
-        }))
+            sourceKind: "user_defined",
+            origin: "user_defined",
+            startedAt: patch.startedAt ?? trip.startedAt,
+            endedAt: patch.endedAt ?? trip.endedAt,
+            title: patch.label ??
+                trip.label ??
+                `${trip.startPlace?.label ?? "Unknown"} → ${trip.endPlace?.label ?? "Unknown"}`,
+            subtitle: "Migrated user-defined move correction.",
+            placeLabel: trip.endPlace?.label ?? trip.startPlace?.label ?? null,
+            tags: patch.tags ?? trip.tags,
+            distanceMeters: patch.distanceMeters ?? trip.distanceMeters,
+            averageSpeedMps: patch.averageSpeedMps ?? trip.averageSpeedMps ?? null,
+            editable: true,
+            legacyOriginKey: `trip-override:${row.trip_external_uid}`,
+            metadata: {
+                migratedFrom: "movement_trip_overrides",
+                tripExternalUid: row.trip_external_uid
+            }
+        });
+    }
+}
+function rebuildAutomaticMovementBoxes(userId) {
+    migrateLegacyMovementCorrectionsToUserBoxes(userId);
+    reconcileMovementOverlapValidation(userId);
+    const placeRows = listMovementPlaceRows([userId]);
+    const placesById = new Map(placeRows.map((row) => {
+        const mapped = mapMovementPlace(row);
+        return [mapped.id, mapped];
+    }));
+    const stayRows = listMovementStayRows([userId]);
+    const tripRows = listMovementTripRows([userId]);
+    const tripIds = tripRows.map((row) => row.id);
+    const pointsByTrip = new Map();
+    listTripPoints(tripIds).forEach((point) => {
+        pointsByTrip.set(point.trip_id, [...(pointsByTrip.get(point.trip_id) ?? []), point]);
+    });
+    const stopsByTrip = new Map();
+    listTripStops(tripIds).forEach((stop) => {
+        stopsByTrip.set(stop.trip_id, [...(stopsByTrip.get(stop.trip_id) ?? []), stop]);
+    });
+    const rawSegments = [
+        ...stayRows.map((row) => {
+            const stay = mapMovementStay(row, placesById);
+            return {
+                id: row.id,
+                kind: "stay",
+                startedAt: stay.startedAt,
+                endedAt: stay.endedAt,
+                payload: stay,
+                startBoundary: {
+                    latitude: stay.centerLatitude,
+                    longitude: stay.centerLongitude,
+                    placeLabel: stay.place?.label ?? stay.label ?? null,
+                    placeExternalUid: stay.place?.externalUid ?? null
+                },
+                endBoundary: {
+                    latitude: stay.centerLatitude,
+                    longitude: stay.centerLongitude,
+                    placeLabel: stay.place?.label ?? stay.label ?? null,
+                    placeExternalUid: stay.place?.externalUid ?? null
+                }
+            };
+        }),
+        ...tripRows.map((row) => {
+            const trip = mapMovementTrip(row, placesById, pointsByTrip.get(row.id) ?? [], stopsByTrip.get(row.id) ?? []);
+            return {
+                id: row.id,
+                kind: "trip",
+                startedAt: trip.startedAt,
+                endedAt: trip.endedAt,
+                payload: trip,
+                startBoundary: trip.points[0] || trip.startPlace
+                    ? {
+                        latitude: trip.points[0]?.latitude ?? trip.startPlace?.latitude ?? 0,
+                        longitude: trip.points[0]?.longitude ?? trip.startPlace?.longitude ?? 0,
+                        placeLabel: trip.startPlace?.label ?? null,
+                        placeExternalUid: trip.startPlace?.externalUid ?? null
+                    }
+                    : null,
+                endBoundary: trip.points[trip.points.length - 1] || trip.endPlace
+                    ? {
+                        latitude: trip.points[trip.points.length - 1]?.latitude ??
+                            trip.endPlace?.latitude ??
+                            0,
+                        longitude: trip.points[trip.points.length - 1]?.longitude ??
+                            trip.endPlace?.longitude ??
+                            0,
+                        placeLabel: trip.endPlace?.label ?? null,
+                        placeExternalUid: trip.endPlace?.externalUid ?? null
+                    }
+                    : null
+            };
+        })
     ]
+        .filter((segment) => segment.kind === "stay"
+        ? !hasInvalidMovementRecord(segment.payload.metadata)
+        : !hasInvalidMovementRecord(segment.payload.metadata))
+        .sort((left, right) => left.startedAt.localeCompare(right.startedAt) ||
+        left.endedAt.localeCompare(right.endedAt));
+    const automaticSegments = normalizeMovementCoverageSegments(rawSegments, {
+        rangeEnd: nowIso()
+    });
+    getDatabase()
+        .prepare(`DELETE FROM movement_boxes
+       WHERE user_id = ?
+         AND source_kind = 'automatic'`)
+        .run(userId);
+    for (const segment of automaticSegments) {
+        if (segment.durationSeconds <= 0) {
+            continue;
+        }
+        if (segment.kind === "stay" && segment.payload) {
+            const stay = segment.payload;
+            const rawStayId = stay.id;
+            insertMovementBox({
+                id: `mba_${rawStayId}`,
+                userId,
+                kind: "stay",
+                sourceKind: "automatic",
+                origin: segment.origin,
+                startedAt: segment.startedAt,
+                endedAt: segment.endedAt,
+                title: stay.place?.label ?? stay.label ?? "Stay",
+                subtitle: stay.place?.categoryTags.join(" · ") ||
+                    (stay.classification === "stationary" ? "Stationary" : stay.classification),
+                placeLabel: stay.place?.label ?? stay.label ?? null,
+                anchorExternalUid: stay.place?.externalUid ?? null,
+                tags: uniqStrings([
+                    ...(stay.place?.categoryTags ?? []),
+                    ...(Array.isArray(stay.metrics.tags)
+                        ? (stay.metrics.tags ?? [])
+                        : [])
+                ]),
+                editable: false,
+                rawStayIds: [rawStayId],
+                hasLegacyCorrections: legacyStayHasCorrections(userId, stay.externalUid),
+                metadata: {
+                    syncSource: stay.pairingSessionId ? "companion" : "forge"
+                }
+            });
+            continue;
+        }
+        if (segment.kind === "trip" && segment.payload) {
+            const trip = segment.payload;
+            insertMovementBox({
+                id: `mba_${trip.id}`,
+                userId,
+                kind: "trip",
+                sourceKind: "automatic",
+                origin: segment.origin,
+                startedAt: segment.startedAt,
+                endedAt: segment.endedAt,
+                title: trip.label ||
+                    `${trip.startPlace?.label ?? "Unknown"} → ${trip.endPlace?.label ?? "Unknown"}`,
+                subtitle: `${round(trip.distanceMeters / 1000, 1)} km · ${trip.activityType || trip.travelMode}`,
+                placeLabel: trip.endPlace?.label ?? trip.startPlace?.label ?? null,
+                tags: uniqStrings([
+                    ...trip.tags,
+                    ...(trip.startPlace?.categoryTags ?? []),
+                    ...(trip.endPlace?.categoryTags ?? [])
+                ]),
+                distanceMeters: trip.distanceMeters,
+                averageSpeedMps: trip.averageSpeedMps ?? null,
+                editable: false,
+                rawTripIds: [trip.id],
+                rawPointCount: trip.points.length,
+                hasLegacyCorrections: legacyTripHasCorrections(userId, trip.externalUid),
+                metadata: {
+                    syncSource: trip.pairingSessionId ? "companion" : "forge"
+                }
+            });
+            continue;
+        }
+        insertMovementBox({
+            id: `mba_${segment.id}`,
+            userId,
+            kind: segment.kind,
+            sourceKind: "automatic",
+            origin: segment.origin,
+            startedAt: segment.startedAt,
+            endedAt: segment.endedAt,
+            title: segment.kind === "missing"
+                ? "Missing data"
+                : segment.origin === "continued_stay"
+                    ? segment.placeLabel ?? "Continued stay"
+                    : segment.kind === "stay"
+                        ? segment.placeLabel ?? "Repaired stay"
+                        : segment.placeLabel ?? "Repaired move",
+            subtitle: segment.kind === "missing"
+                ? "No trusted movement signal for this period."
+                : segment.kind === "stay"
+                    ? segment.origin === "continued_stay"
+                        ? "Short stationary gap carried forward into one continuous stay."
+                        : segment.suppressedShortJump
+                            ? "Short jump under five minutes suppressed into stay continuity."
+                            : "Short gap repaired as a stay between known anchors."
+                    : "Short gap repaired as a move between known anchors.",
+            placeLabel: segment.placeLabel ?? null,
+            anchorExternalUid: segment.startBoundary?.placeExternalUid ??
+                segment.endBoundary?.placeExternalUid ??
+                null,
+            tags: uniqStrings([
+                segment.origin,
+                ...(segment.suppressedShortJump ? ["suppressed-short-jump"] : []),
+                ...(segment.kind === "missing" ? ["missing-data"] : [])
+            ]),
+            distanceMeters: segment.kind === "trip" ? segment.displacementMeters ?? null : null,
+            averageSpeedMps: segment.kind === "trip" && segment.displacementMeters != null
+                ? segment.displacementMeters / Math.max(1, segment.durationSeconds)
+                : null,
+            editable: false,
+            metadata: {
+                syncSource: "automatic"
+            }
+        });
+    }
+    recomputeMovementBoxOverrideState(userId);
+}
+function ensureAutomaticMovementBoxes(userIds) {
+    for (const userId of userIds) {
+        migrateLegacyMovementCorrectionsToUserBoxes(userId);
+        const hasAutomatic = listMovementBoxRows({
+            userIds: [userId],
+            sourceKinds: ["automatic"]
+        }).length > 0;
+        if (!hasAutomatic) {
+            rebuildAutomaticMovementBoxes(userId);
+        }
+    }
+}
+function projectMovementBoxes(input) {
+    ensureAutomaticMovementBoxes(input.userIds);
+    input.userIds.forEach(recomputeMovementBoxOverrideState);
+    const placeRows = listMovementPlaceRows(input.userIds);
+    const placesById = new Map(placeRows
+        .map((row) => mapMovementPlace(row))
+        .map((place) => [place.id, place]));
+    const placesByExternalUid = new Map(placeRows
+        .map((row) => mapMovementPlace(row))
+        .map((place) => [place.externalUid, place]));
+    const stayRows = listMovementStayRows(input.userIds);
+    const rawStayById = new Map(stayRows.map((row) => [row.id, row]));
+    const tripRows = listMovementTripRows(input.userIds);
+    const tripIds = tripRows.map((row) => row.id);
+    const pointsByTrip = new Map();
+    listTripPoints(tripIds).forEach((point) => {
+        pointsByTrip.set(point.trip_id, [...(pointsByTrip.get(point.trip_id) ?? []), point]);
+    });
+    const rawTripById = new Map(tripRows.map((row) => [row.id, row]));
+    const allRows = listMovementBoxRows({ userIds: input.userIds });
+    const inRange = allRows.filter((row) => {
+        const rowStartedAt = row.true_started_at ?? row.started_at;
+        const rowEndedAt = row.true_ended_at ?? row.ended_at;
+        if (input.rangeStart && rowEndedAt <= input.rangeStart) {
+            return false;
+        }
+        if (input.rangeEnd && rowStartedAt >= input.rangeEnd) {
+            return false;
+        }
+        return true;
+    });
+    const automaticRows = inRange.filter((row) => row.source_kind === "automatic");
+    const userRows = inRange.filter((row) => row.source_kind === "user_defined");
+    const projectedAutomatic = [];
+    const userProjected = userRows.flatMap((row) => {
+        const base = mapMovementBoxRow(row);
+        const trueStartedAt = base.trueStartedAt;
+        const trueEndedAt = base.trueEndedAt;
+        const fragments = subtractMovementOverrideRanges(trueStartedAt, trueEndedAt, movementBoxOverrideRanges(row));
+        return fragments.map((fragment, index) => ({
+            ...base,
+            id: fragments.length === 1
+                ? row.id
+                : `${row.id}::fragment:${index}`,
+            startedAt: fragment.startedAt,
+            endedAt: fragment.endedAt,
+            visibleStartedAt: fragment.startedAt,
+            visibleEndedAt: fragment.endedAt,
+            durationSeconds: durationSeconds(fragment.startedAt, fragment.endedAt),
+            metadata: {
+                ...base.metadata,
+                projectedFromBoxId: row.id,
+                projectedFragmentIndex: index
+            }
+        }));
+    });
+    for (const automatic of automaticRows) {
+        let fragments = [
+            {
+                startedAt: automatic.true_started_at ?? automatic.started_at,
+                endedAt: automatic.true_ended_at ?? automatic.ended_at
+            }
+        ];
+        const overlappingUsers = userRows.filter((user) => movementBoxOverlapsRange(user, automatic.true_started_at ?? automatic.started_at, automatic.true_ended_at ?? automatic.ended_at));
+        for (const user of overlappingUsers) {
+            const userStartedAt = user.true_started_at ?? user.started_at;
+            const userEndedAt = user.true_ended_at ?? user.ended_at;
+            fragments = fragments.flatMap((fragment) => {
+                if (userStartedAt >= fragment.endedAt || userEndedAt <= fragment.startedAt) {
+                    return [fragment];
+                }
+                const nextFragments = [];
+                if (fragment.startedAt < userStartedAt) {
+                    nextFragments.push({
+                        startedAt: fragment.startedAt,
+                        endedAt: userStartedAt
+                    });
+                }
+                if (fragment.endedAt > userEndedAt) {
+                    nextFragments.push({
+                        startedAt: userEndedAt,
+                        endedAt: fragment.endedAt
+                    });
+                }
+                return nextFragments;
+            });
+        }
+        for (const [index, fragment] of fragments.entries()) {
+            if (durationSeconds(fragment.startedAt, fragment.endedAt) <= 0) {
+                continue;
+            }
+            projectedAutomatic.push({
+                ...mapMovementBoxRow(automatic),
+                id: fragment.startedAt === (automatic.true_started_at ?? automatic.started_at) &&
+                    fragment.endedAt === (automatic.true_ended_at ?? automatic.ended_at)
+                    ? automatic.id
+                    : `${automatic.id}::fragment:${index}`,
+                startedAt: fragment.startedAt,
+                endedAt: fragment.endedAt,
+                visibleStartedAt: fragment.startedAt,
+                visibleEndedAt: fragment.endedAt,
+                durationSeconds: durationSeconds(fragment.startedAt, fragment.endedAt)
+            });
+        }
+    }
+    const projected = [...projectedAutomatic, ...userProjected]
+        .map((segment) => {
+        const startedAt = input.rangeStart && segment.startedAt < input.rangeStart
+            ? input.rangeStart
+            : segment.startedAt;
+        const endedAt = input.rangeEnd && segment.endedAt > input.rangeEnd
+            ? input.rangeEnd
+            : segment.endedAt;
+        return {
+            ...segment,
+            startedAt,
+            endedAt,
+            visibleStartedAt: startedAt,
+            visibleEndedAt: endedAt,
+            durationSeconds: durationSeconds(startedAt, endedAt)
+        };
+    })
+        .filter((segment) => segment.durationSeconds > 0)
         .sort((left, right) => left.startedAt.localeCompare(right.startedAt) ||
         left.endedAt.localeCompare(right.endedAt) ||
         left.kind.localeCompare(right.kind) ||
         left.id.localeCompare(right.id));
-    const validChronological = chronological.filter((segment) => segment.kind === "stay"
-        ? !hasInvalidMovementRecord(segment.stay.metadata)
-        : !hasInvalidMovementRecord(segment.trip.metadata));
+    return ensureProjectedMovementBoxCoverage(projected, {
+        rangeStart: input.rangeStart,
+        rangeEnd: input.rangeEnd,
+        resolveBoundary: (segment, kind) => {
+            const rawStayId = segment.rawStayIds[0] ?? null;
+            if (rawStayId) {
+                const rawStay = rawStayById.get(rawStayId);
+                if (rawStay) {
+                    const mappedPlace = rawStay.place_id != null ? placesById.get(rawStay.place_id) ?? null : null;
+                    return {
+                        latitude: rawStay.center_latitude,
+                        longitude: rawStay.center_longitude,
+                        placeLabel: mappedPlace?.label ?? segment.placeLabel ?? null,
+                        placeExternalUid: mappedPlace?.externalUid ?? segment.anchorExternalUid ?? null
+                    };
+                }
+            }
+            const rawTripId = segment.rawTripIds[0] ?? null;
+            if (rawTripId) {
+                const rawTrip = rawTripById.get(rawTripId);
+                if (rawTrip) {
+                    const points = pointsByTrip.get(rawTripId) ?? [];
+                    const point = kind === "start" ? points[0] ?? null : points[points.length - 1] ?? null;
+                    const placeId = kind === "start" ? rawTrip.start_place_id : rawTrip.end_place_id;
+                    const placeRow = placeId
+                        ? placeRows.find((row) => row.id === placeId) ?? null
+                        : null;
+                    const mappedPlace = placeRow ? mapMovementPlace(placeRow) : null;
+                    return {
+                        latitude: point?.latitude ?? mappedPlace?.latitude ?? null,
+                        longitude: point?.longitude ?? mappedPlace?.longitude ?? null,
+                        placeLabel: mappedPlace?.label ?? segment.placeLabel ?? null,
+                        placeExternalUid: mappedPlace?.externalUid ?? null
+                    };
+                }
+            }
+            const mappedPlace = segment.anchorExternalUid
+                ? placesByExternalUid.get(segment.anchorExternalUid) ?? null
+                : null;
+            return {
+                latitude: mappedPlace?.latitude ?? null,
+                longitude: mappedPlace?.longitude ?? null,
+                placeLabel: mappedPlace?.label ?? segment.placeLabel ?? null,
+                placeExternalUid: mappedPlace?.externalUid ?? segment.anchorExternalUid ?? null
+            };
+        }
+    });
+}
+export function createMovementUserBox(input, context) {
+    const parsed = movementUserBoxCreateSchema.parse(input);
+    const row = insertMovementBox({
+        userId: input.userId,
+        kind: parsed.kind,
+        sourceKind: "user_defined",
+        origin: parsed.kind === "missing" ? "user_invalidated" : "user_defined",
+        startedAt: parsed.startedAt,
+        endedAt: parsed.endedAt,
+        title: parsed.title ||
+            (parsed.kind === "missing"
+                ? "User-defined missing data"
+                : parsed.kind === "stay"
+                    ? parsed.placeLabel ?? "Manual stay"
+                    : "Manual move"),
+        subtitle: parsed.subtitle ||
+            (parsed.kind === "missing"
+                ? "User invalidated automatic movement here."
+                : "User-defined movement box."),
+        placeLabel: parsed.placeLabel,
+        anchorExternalUid: parsed.anchorExternalUid,
+        tags: parsed.tags,
+        distanceMeters: parsed.distanceMeters,
+        averageSpeedMps: parsed.averageSpeedMps,
+        editable: true,
+        metadata: parsed.metadata
+    });
+    recordActivityEvent({
+        entityType: "system",
+        entityId: row.id,
+        eventType: "movement_user_box_created",
+        title: "Movement box created",
+        description: `Created a ${row.kind} movement box.`,
+        actor: context.actor ?? null,
+        source: context.source,
+        metadata: {
+            sourceKind: row.source_kind,
+            origin: row.origin
+        }
+    });
+    rebuildAutomaticMovementBoxes(input.userId);
+    return mapMovementBoxRow(row);
+}
+export function updateMovementUserBox(boxId, patch, context, options = {}) {
+    const existing = getMovementBoxRow(boxId);
+    if (!existing || existing.source_kind !== "user_defined" || existing.deleted_at) {
+        return undefined;
+    }
+    if (options.userId && existing.user_id !== options.userId) {
+        return undefined;
+    }
+    const parsed = movementUserBoxPatchSchema.parse(patch);
+    const nextStartedAt = parsed.startedAt ?? existing.started_at;
+    const nextEndedAt = parsed.endedAt ?? existing.ended_at;
+    const row = insertMovementBox({
+        id: existing.id,
+        userId: existing.user_id,
+        kind: parsed.kind ?? existing.kind,
+        sourceKind: "user_defined",
+        origin: (parsed.kind ?? existing.kind) === "missing"
+            ? "user_invalidated"
+            : "user_defined",
+        startedAt: nextStartedAt,
+        endedAt: nextEndedAt,
+        title: parsed.title ?? existing.title,
+        subtitle: parsed.subtitle ?? existing.subtitle,
+        placeLabel: parsed.placeLabel === undefined ? existing.place_label : parsed.placeLabel,
+        anchorExternalUid: parsed.anchorExternalUid === undefined
+            ? existing.anchor_external_uid
+            : parsed.anchorExternalUid,
+        tags: parsed.tags ?? movementBoxTags(existing),
+        distanceMeters: parsed.distanceMeters === undefined
+            ? existing.distance_meters
+            : parsed.distanceMeters,
+        averageSpeedMps: parsed.averageSpeedMps === undefined
+            ? existing.average_speed_mps
+            : parsed.averageSpeedMps,
+        editable: true,
+        overrideCount: existing.override_count,
+        overriddenAutomaticBoxIds: movementBoxOverriddenAutomaticBoxIds(existing),
+        rawStayIds: movementBoxRawStayIds(existing),
+        rawTripIds: movementBoxRawTripIds(existing),
+        rawPointCount: existing.raw_point_count,
+        hasLegacyCorrections: existing.has_legacy_corrections === 1,
+        legacyOriginKey: existing.legacy_origin_key,
+        metadata: {
+            ...movementBoxMetadata(existing),
+            ...(parsed.metadata ?? {})
+        },
+        deletedAt: existing.deleted_at,
+        createdAt: existing.created_at,
+        updatedAt: nowIso()
+    });
+    recordActivityEvent({
+        entityType: "system",
+        entityId: row.id,
+        eventType: "movement_user_box_updated",
+        title: "Movement box updated",
+        description: `Updated a user-defined ${row.kind} box.`,
+        actor: context.actor ?? null,
+        source: context.source,
+        metadata: {
+            sourceKind: row.source_kind,
+            origin: row.origin
+        }
+    });
+    rebuildAutomaticMovementBoxes(existing.user_id);
+    return mapMovementBoxRow(row);
+}
+export function deleteMovementUserBox(boxId, context, options = {}) {
+    const existing = getMovementBoxRow(boxId);
+    if (!existing || existing.source_kind !== "user_defined" || existing.deleted_at) {
+        return undefined;
+    }
+    if (options.userId && existing.user_id !== options.userId) {
+        return undefined;
+    }
+    softDeleteMovementBox(boxId);
+    recordActivityEvent({
+        entityType: "system",
+        entityId: boxId,
+        eventType: "movement_user_box_deleted",
+        title: "Movement box deleted",
+        description: `Deleted a user-defined ${existing.kind} box.`,
+        actor: context.actor ?? null,
+        source: context.source,
+        metadata: {
+            sourceKind: existing.source_kind,
+            origin: existing.origin
+        }
+    });
+    rebuildAutomaticMovementBoxes(existing.user_id);
+    return {
+        deletedBoxId: boxId
+    };
+}
+export function invalidateAutomaticMovementBox(boxId, input, context, options = {}) {
+    const automatic = getMovementBoxRow(boxId);
+    if (!automatic || automatic.source_kind !== "automatic" || automatic.deleted_at) {
+        return undefined;
+    }
+    if (options.userId && automatic.user_id !== options.userId) {
+        return undefined;
+    }
+    const parsed = movementAutomaticBoxInvalidateSchema.parse(input);
+    const startedAt = parsed.startedAt ?? automatic.started_at;
+    const endedAt = parsed.endedAt ?? automatic.ended_at;
+    const created = createMovementUserBox({
+        userId: automatic.user_id,
+        kind: "missing",
+        startedAt,
+        endedAt,
+        title: parsed.title ?? "User invalidated automatic movement",
+        subtitle: parsed.subtitle ?? `Overrides ${automatic.title || automatic.kind} with missing data.`,
+        placeLabel: automatic.place_label,
+        anchorExternalUid: automatic.anchor_external_uid,
+        tags: uniqStrings(["user-invalidated", ...movementBoxTags(automatic)]),
+        metadata: {
+            ...parsed.metadata,
+            invalidatedAutomaticBoxId: automatic.id
+        }
+    }, context);
+    rebuildAutomaticMovementBoxes(automatic.user_id);
+    return {
+        box: created
+    };
+}
+function buildProjectedMovementTimelineSegments(userIds) {
+    const places = listMovementPlaceRows(userIds).map(mapMovementPlace);
+    const placesById = new Map(places.map((place) => [place.id, place]));
+    const stayRows = listMovementStayRows(userIds);
+    const tripRows = listMovementTripRows(userIds);
+    const tripIds = tripRows.map((row) => row.id);
+    const pointsByTrip = new Map();
+    listTripPoints(tripIds).forEach((point) => {
+        pointsByTrip.set(point.trip_id, [...(pointsByTrip.get(point.trip_id) ?? []), point]);
+    });
+    const stopsByTrip = new Map();
+    listTripStops(tripIds).forEach((stop) => {
+        stopsByTrip.set(stop.trip_id, [...(stopsByTrip.get(stop.trip_id) ?? []), stop]);
+    });
+    const stayPayloadById = new Map(stayRows.map((row) => {
+        const stay = mapMovementStay(row, placesById);
+        return [stay.id, stay];
+    }));
+    const tripPayloadById = new Map(tripRows.map((row) => {
+        const trip = mapMovementTrip(row, placesById, pointsByTrip.get(row.id) ?? [], stopsByTrip.get(row.id) ?? []);
+        return [trip.id, trip];
+    }));
+    const projected = projectMovementBoxes({ userIds });
     let nextStayLane = "left";
     const stayLaneById = new Map();
-    for (const segment of validChronological) {
-        if (segment.kind === "stay") {
-            stayLaneById.set(segment.id, nextStayLane);
+    for (const box of projected) {
+        if (box.kind === "stay") {
+            stayLaneById.set(box.id, nextStayLane);
             nextStayLane = nextStayLane === "left" ? "right" : "left";
         }
     }
-    const timelineSource = parsed.includeInvalid ? chronological : validChronological;
-    const decorated = timelineSource.map((segment, index) => {
-        const previousStayId = [...timelineSource.slice(0, index)]
+    const decorated = projected.map((segment, index) => {
+        const previousStayId = [...projected.slice(0, index)]
             .reverse()
             .find((candidate) => candidate.kind === "stay")?.id;
         const previousStayLane = previousStayId
             ? stayLaneById.get(previousStayId)
             : undefined;
-        const nextStayLaneId = timelineSource
+        const nextStayLaneId = projected
             .slice(index + 1)
             .find((candidate) => candidate.kind === "stay")?.id;
         const nextStayLane = nextStayLaneId ? stayLaneById.get(nextStayLaneId) : undefined;
@@ -1898,62 +3500,266 @@ export function getMovementTimeline(input) {
             startedAt: segment.startedAt,
             endedAt: segment.endedAt
         };
-        if (segment.kind === "stay") {
-            const invalid = hasInvalidMovementRecord(segment.stay.metadata);
+        const rawStay = segment.rawStayIds.length > 0 ? stayPayloadById.get(segment.rawStayIds[0]) ?? null : null;
+        const rawTrip = segment.rawTripIds.length > 0 ? tripPayloadById.get(segment.rawTripIds[0]) ?? null : null;
+        const syncSource = String(segment.metadata.syncSource ?? segment.sourceKind);
+        if (segment.kind === "missing") {
+            const laneSide = previousStayLane ?? nextStayLane ?? "left";
+            return {
+                id: segment.id,
+                boxId: segment.boxId,
+                kind: "missing",
+                sourceKind: segment.sourceKind,
+                origin: segment.origin,
+                editable: segment.editable,
+                startedAt: segment.startedAt,
+                endedAt: segment.endedAt,
+                trueStartedAt: segment.trueStartedAt,
+                trueEndedAt: segment.trueEndedAt,
+                visibleStartedAt: segment.visibleStartedAt,
+                visibleEndedAt: segment.visibleEndedAt,
+                durationSeconds: segment.durationSeconds,
+                laneSide,
+                connectorFromLane: previousStayLane ?? laneSide,
+                connectorToLane: nextStayLane ?? laneSide,
+                title: segment.title,
+                subtitle: segment.subtitle,
+                placeLabel: segment.placeLabel,
+                tags: segment.tags,
+                isInvalid: false,
+                syncSource,
+                cursor: encodeMovementTimelineCursor(cursor),
+                overrideCount: segment.overrideCount,
+                overriddenAutomaticBoxIds: segment.overriddenAutomaticBoxIds,
+                overriddenUserBoxIds: segment.overriddenUserBoxIds,
+                isFullyHidden: segment.isFullyHidden,
+                rawStayIds: segment.rawStayIds,
+                rawTripIds: segment.rawTripIds,
+                rawPointCount: segment.rawPointCount,
+                hasLegacyCorrections: segment.hasLegacyCorrections,
+                stay: null,
+                trip: null
+            };
+        }
+        if (segment.kind === "stay" && rawStay && segment.sourceKind === "automatic" && segment.origin === "recorded") {
+            const invalid = hasInvalidMovementRecord(rawStay.metadata);
             const laneSide = stayLaneById.get(segment.id) ?? "left";
             return {
                 id: segment.id,
+                boxId: segment.boxId,
                 kind: "stay",
+                sourceKind: segment.sourceKind,
+                origin: segment.origin,
+                editable: segment.editable,
                 startedAt: segment.startedAt,
                 endedAt: segment.endedAt,
-                durationSeconds: segment.stay.durationSeconds,
+                trueStartedAt: segment.trueStartedAt,
+                trueEndedAt: segment.trueEndedAt,
+                visibleStartedAt: segment.visibleStartedAt,
+                visibleEndedAt: segment.visibleEndedAt,
+                durationSeconds: segment.durationSeconds,
                 laneSide,
                 connectorFromLane: laneSide,
                 connectorToLane: laneSide,
-                title: buildMovementTimelineTitleForStay(segment.stay),
-                subtitle: buildMovementTimelineSubtitleForStay(segment.stay),
-                placeLabel: segment.stay.place?.label ?? segment.stay.placeId ?? null,
-                tags: uniqStrings([
-                    ...(segment.stay.place?.categoryTags ?? []),
-                    ...(Array.isArray(segment.stay.metrics.tags)
-                        ? (segment.stay.metrics.tags ?? [])
-                        : [])
-                ]),
+                title: segment.title,
+                subtitle: segment.subtitle,
+                placeLabel: segment.placeLabel,
+                tags: segment.tags,
                 isInvalid: invalid,
-                syncSource: segment.stay.pairingSessionId ? "companion" : "forge",
+                syncSource,
                 cursor: encodeMovementTimelineCursor(cursor),
-                stay: segment.stay,
+                overrideCount: segment.overrideCount,
+                overriddenAutomaticBoxIds: segment.overriddenAutomaticBoxIds,
+                overriddenUserBoxIds: segment.overriddenUserBoxIds,
+                isFullyHidden: segment.isFullyHidden,
+                rawStayIds: segment.rawStayIds,
+                rawTripIds: segment.rawTripIds,
+                rawPointCount: segment.rawPointCount,
+                hasLegacyCorrections: segment.hasLegacyCorrections,
+                stay: rawStay,
                 trip: null
             };
         }
-        const invalid = hasInvalidMovementRecord(segment.trip.metadata);
+        if (segment.kind === "stay") {
+            const laneSide = previousStayLane ?? nextStayLane ?? "left";
+            return {
+                id: segment.id,
+                boxId: segment.boxId,
+                kind: "stay",
+                sourceKind: segment.sourceKind,
+                origin: segment.origin,
+                editable: segment.editable,
+                startedAt: segment.startedAt,
+                endedAt: segment.endedAt,
+                trueStartedAt: segment.trueStartedAt,
+                trueEndedAt: segment.trueEndedAt,
+                visibleStartedAt: segment.visibleStartedAt,
+                visibleEndedAt: segment.visibleEndedAt,
+                durationSeconds: segment.durationSeconds,
+                laneSide,
+                connectorFromLane: previousStayLane ?? laneSide,
+                connectorToLane: nextStayLane ?? laneSide,
+                title: segment.title,
+                subtitle: segment.subtitle,
+                placeLabel: segment.placeLabel,
+                tags: segment.tags,
+                isInvalid: false,
+                syncSource,
+                cursor: encodeMovementTimelineCursor(cursor),
+                overrideCount: segment.overrideCount,
+                overriddenAutomaticBoxIds: segment.overriddenAutomaticBoxIds,
+                overriddenUserBoxIds: segment.overriddenUserBoxIds,
+                isFullyHidden: segment.isFullyHidden,
+                rawStayIds: segment.rawStayIds,
+                rawTripIds: segment.rawTripIds,
+                rawPointCount: segment.rawPointCount,
+                hasLegacyCorrections: segment.hasLegacyCorrections,
+                stay: null,
+                trip: null
+            };
+        }
+        if (!rawTrip || segment.sourceKind !== "automatic" || segment.origin !== "recorded") {
+            const laneSide = nextStayLane ?? previousStayLane ?? "left";
+            return {
+                id: segment.id,
+                boxId: segment.boxId,
+                kind: "trip",
+                sourceKind: segment.sourceKind,
+                origin: segment.origin,
+                editable: segment.editable,
+                startedAt: segment.startedAt,
+                endedAt: segment.endedAt,
+                trueStartedAt: segment.trueStartedAt,
+                trueEndedAt: segment.trueEndedAt,
+                visibleStartedAt: segment.visibleStartedAt,
+                visibleEndedAt: segment.visibleEndedAt,
+                durationSeconds: segment.durationSeconds,
+                laneSide,
+                connectorFromLane: previousStayLane ?? laneSide,
+                connectorToLane: nextStayLane ?? laneSide,
+                title: segment.title,
+                subtitle: segment.subtitle,
+                placeLabel: segment.placeLabel,
+                tags: segment.tags,
+                isInvalid: false,
+                syncSource,
+                cursor: encodeMovementTimelineCursor(cursor),
+                overrideCount: segment.overrideCount,
+                overriddenAutomaticBoxIds: segment.overriddenAutomaticBoxIds,
+                overriddenUserBoxIds: segment.overriddenUserBoxIds,
+                isFullyHidden: segment.isFullyHidden,
+                rawStayIds: segment.rawStayIds,
+                rawTripIds: segment.rawTripIds,
+                rawPointCount: segment.rawPointCount,
+                hasLegacyCorrections: segment.hasLegacyCorrections,
+                stay: null,
+                trip: null
+            };
+        }
+        const invalid = hasInvalidMovementRecord(rawTrip.metadata);
         const laneSide = nextStayLane ?? previousStayLane ?? "left";
         return {
             id: segment.id,
+            boxId: segment.boxId,
             kind: "trip",
+            sourceKind: segment.sourceKind,
+            origin: segment.origin,
+            editable: segment.editable,
             startedAt: segment.startedAt,
             endedAt: segment.endedAt,
-            durationSeconds: segment.trip.durationSeconds,
+            trueStartedAt: segment.trueStartedAt,
+            trueEndedAt: segment.trueEndedAt,
+            visibleStartedAt: segment.visibleStartedAt,
+            visibleEndedAt: segment.visibleEndedAt,
+            durationSeconds: segment.durationSeconds,
             laneSide,
             connectorFromLane: previousStayLane ?? laneSide,
             connectorToLane: nextStayLane ?? laneSide,
-            title: buildMovementTimelineTitleForTrip(segment.trip),
-            subtitle: buildMovementTimelineSubtitleForTrip(segment.trip),
-            placeLabel: segment.trip.endPlace?.label ??
-                segment.trip.startPlace?.label ??
-                null,
-            tags: uniqStrings([
-                ...segment.trip.tags,
-                ...(segment.trip.startPlace?.categoryTags ?? []),
-                ...(segment.trip.endPlace?.categoryTags ?? [])
-            ]),
+            title: segment.title,
+            subtitle: segment.subtitle,
+            placeLabel: segment.placeLabel,
+            tags: segment.tags,
             isInvalid: invalid,
-            syncSource: segment.trip.pairingSessionId ? "companion" : "forge",
+            syncSource,
             cursor: encodeMovementTimelineCursor(cursor),
+            overrideCount: segment.overrideCount,
+            overriddenAutomaticBoxIds: segment.overriddenAutomaticBoxIds,
+            overriddenUserBoxIds: segment.overriddenUserBoxIds,
+            isFullyHidden: segment.isFullyHidden,
+            rawStayIds: segment.rawStayIds,
+            rawTripIds: segment.rawTripIds,
+            rawPointCount: segment.rawPointCount,
+            hasLegacyCorrections: segment.hasLegacyCorrections,
             stay: null,
-            trip: segment.trip
+            trip: rawTrip
         };
     });
+    return decorated;
+}
+export function resolveMovementTimelineSegmentForBox(userId, boxId) {
+    return buildProjectedMovementTimelineSegments([userId]).find((segment) => segment.boxId === boxId);
+}
+export function analyzeMovementUserBoxPreflight(input) {
+    const parsed = movementUserBoxPreflightSchema.parse(input);
+    const visibleRangeStart = parsed.rangeStart ?? null;
+    const visibleRangeEnd = parsed.rangeEnd ?? null;
+    const allRows = listMovementBoxRows({ userIds: [input.userId] });
+    const automaticRows = allRows.filter((row) => row.source_kind === "automatic");
+    const userRows = allRows.filter((row) => row.source_kind === "user_defined" &&
+        row.id !== (parsed.excludeBoxId ?? null));
+    const affectedAutomaticBoxIds = automaticRows
+        .filter((row) => movementBoxOverlapsRange(row, parsed.startedAt, parsed.endedAt))
+        .map((row) => row.id);
+    const affectedUserRows = userRows.filter((row) => movementBoxOverlapsRange(row, parsed.startedAt, parsed.endedAt));
+    const fullyOverriddenUserBoxIds = [];
+    const trimmedUserBoxIds = [];
+    for (const row of affectedUserRows) {
+        const fragments = subtractMovementOverrideRanges(row.started_at, row.ended_at, [
+            {
+                startedAt: parsed.startedAt > row.started_at ? parsed.startedAt : row.started_at,
+                endedAt: parsed.endedAt < row.ended_at ? parsed.endedAt : row.ended_at
+            }
+        ]);
+        if (fragments.length === 0) {
+            fullyOverriddenUserBoxIds.push(row.id);
+        }
+        else {
+            trimmedUserBoxIds.push(row.id);
+        }
+    }
+    const projected = buildProjectedMovementTimelineSegments([input.userId]).filter((segment) => {
+        if (visibleRangeStart && segment.endedAt <= visibleRangeStart) {
+            return false;
+        }
+        if (visibleRangeEnd && segment.startedAt >= visibleRangeEnd) {
+            return false;
+        }
+        return true;
+    });
+    const missingSegments = projected.filter((segment) => segment.kind === "missing");
+    const nearestMissing = [...missingSegments].sort((left, right) => {
+        const leftDistance = Math.min(Math.abs(Date.parse(left.startedAt) - Date.parse(parsed.startedAt)), Math.abs(Date.parse(left.endedAt) - Date.parse(parsed.endedAt)));
+        const rightDistance = Math.min(Math.abs(Date.parse(right.startedAt) - Date.parse(parsed.startedAt)), Math.abs(Date.parse(right.endedAt) - Date.parse(parsed.endedAt)));
+        return leftDistance - rightDistance;
+    })[0] ?? null;
+    return {
+        overlapsAnything: affectedAutomaticBoxIds.length > 0 || affectedUserRows.length > 0,
+        visibleRangeStart: visibleRangeStart ?? projected[0]?.startedAt ?? parsed.startedAt,
+        visibleRangeEnd: visibleRangeEnd ?? projected[projected.length - 1]?.endedAt ?? parsed.endedAt,
+        suggestedStartedAt: nearestMissing?.startedAt ?? null,
+        suggestedEndedAt: nearestMissing?.endedAt ?? null,
+        nearestMissingStartedAt: nearestMissing?.startedAt ?? null,
+        nearestMissingEndedAt: nearestMissing?.endedAt ?? null,
+        affectedAutomaticBoxIds,
+        affectedUserBoxIds: affectedUserRows.map((row) => row.id),
+        fullyOverriddenUserBoxIds,
+        trimmedUserBoxIds
+    };
+}
+export function getMovementTimeline(input) {
+    const parsed = movementTimelineQuerySchema.parse(input);
+    const userIds = parsed.userIds.length > 0 ? parsed.userIds : [getDefaultUser().id];
+    const decorated = buildProjectedMovementTimelineSegments(userIds);
     const descending = [...decorated].sort((left, right) => compareMovementTimelineDescending({
         id: left.id,
         kind: left.kind,
@@ -1982,7 +3788,7 @@ export function getMovementTimeline(input) {
         segments,
         nextCursor,
         hasMore: nextCursor !== null,
-        invalidSegmentCount: chronological.length - validChronological.length
+        invalidSegmentCount: 0
     };
 }
 export function updateMovementStay(stayId, patch, context, options = {}) {
@@ -2555,6 +4361,11 @@ function computeSelectionAggregate(input) {
     const tags = uniqStrings(input.trips.flatMap((trip) => trip.tags).concat(input.stays.flatMap((stay) => Array.isArray(stay.metrics.tags)
         ? (stay.metrics.tags ?? [])
         : [])));
+    const screenTime = getScreenTimeOverlapSummary({
+        startedAt: input.startedAt,
+        endedAt: input.endedAt,
+        userIds: input.userIds
+    });
     return {
         startedAt: input.startedAt,
         endedAt: input.endedAt,
@@ -2571,15 +4382,23 @@ function computeSelectionAggregate(input) {
             return sum + overlapSeconds(input.startedAt, input.endedAt, run.claimedAt, end);
         }, 0),
         placeLabels,
-        tags
+        tags,
+        estimatedScreenTimeSeconds: screenTime.estimatedScreenTimeSeconds,
+        pickupCount: screenTime.pickupCount,
+        notificationCount: screenTime.notificationCount,
+        topApps: screenTime.topApps,
+        topCategories: screenTime.topCategories
     };
 }
 export function getMovementDayDetail(input) {
     const targetDate = input.date ?? dayKey(nowIso());
+    const userIds = input.userIds && input.userIds.length > 0 ? input.userIds : [getDefaultUser().id];
     const placeRows = listMovementPlaceRows(input.userIds);
     const places = placeRows.map(mapMovementPlace);
     const placesById = new Map(places.map((place) => [place.id, place]));
-    const stays = listMovementStayRows(input.userIds, targetDate).map((row) => mapMovementStay(row, placesById));
+    const stays = listMovementStayRows(input.userIds, targetDate)
+        .map((row) => mapMovementStay(row, placesById))
+        .map((stay) => enrichMovementSegmentWithScreenTime(stay, input.userIds));
     const tripRows = listMovementTripRows(input.userIds, { dateKey: targetDate });
     const tripIds = tripRows.map((row) => row.id);
     const pointsByTrip = new Map();
@@ -2590,41 +4409,64 @@ export function getMovementDayDetail(input) {
     listTripStops(tripIds).forEach((stop) => {
         stopsByTrip.set(stop.trip_id, [...(stopsByTrip.get(stop.trip_id) ?? []), stop]);
     });
-    const trips = tripRows.map((row) => mapMovementTrip(row, placesById, pointsByTrip.get(row.id) ?? [], stopsByTrip.get(row.id) ?? []));
-    const allSegments = [
-        ...stays.map((stay) => ({
-            id: stay.id,
-            kind: "stay",
-            startedAt: stay.startedAt,
-            endedAt: stay.endedAt,
-            durationSeconds: stay.durationSeconds,
-            label: stay.place?.label ?? stay.label ?? "Stay",
-            subtitle: stay.place?.categoryTags.join(" · ") ||
-                (stay.classification === "stationary" ? "Stationary" : stay.classification),
-            distanceMeters: 0,
-            averageSpeedMps: 0,
-            colorTone: stay.place?.categoryTags.includes("home")
-                ? "from-sky-400/30 to-indigo-500/12"
-                : "from-white/16 to-white/4",
-            noteCount: stay.note ? 1 : 0
-        })),
-        ...trips.map((trip) => ({
-            id: trip.id,
-            kind: "trip",
-            startedAt: trip.startedAt,
-            endedAt: trip.endedAt,
-            durationSeconds: trip.durationSeconds,
-            label: trip.label ||
-                `${trip.startPlace?.label ?? "Unknown"} → ${trip.endPlace?.label ?? "Unknown"}`,
-            subtitle: `${round(trip.distanceMeters / 1000, 1)} km · ${trip.activityType || trip.travelMode}`,
-            distanceMeters: trip.distanceMeters,
-            averageSpeedMps: trip.averageSpeedMps ?? 0,
-            colorTone: "from-emerald-300/26 to-cyan-400/12",
-            noteCount: trip.note ? 1 : 0
-        }))
-    ].sort((left, right) => Date.parse(left.startedAt) - Date.parse(right.startedAt));
+    const trips = tripRows
+        .map((row) => mapMovementTrip(row, placesById, pointsByTrip.get(row.id) ?? [], stopsByTrip.get(row.id) ?? []))
+        .map((trip) => enrichMovementSegmentWithScreenTime(trip, input.userIds));
     const dayStart = `${targetDate}T00:00:00.000Z`;
     const dayEnd = `${targetDate}T23:59:59.999Z`;
+    const projectedBoxes = projectMovementBoxes({
+        userIds,
+        rangeStart: dayStart,
+        rangeEnd: dayEnd
+    });
+    const stayById = new Map(stays.map((stay) => [stay.id, stay]));
+    const tripById = new Map(trips.map((trip) => [trip.id, trip]));
+    const allSegments = projectedBoxes.map((segment) => {
+        const rawStay = segment.rawStayIds.length > 0 ? stayById.get(segment.rawStayIds[0]) ?? null : null;
+        const rawTrip = segment.rawTripIds.length > 0 ? tripById.get(segment.rawTripIds[0]) ?? null : null;
+        const estimatedScreenTimeSeconds = rawStay?.estimatedScreenTimeSeconds ?? rawTrip?.estimatedScreenTimeSeconds ?? 0;
+        const pickupCount = rawStay?.pickupCount ?? rawTrip?.pickupCount ?? 0;
+        const noteCount = rawStay?.note ? 1 : rawTrip?.note ? 1 : 0;
+        return {
+            id: segment.id,
+            boxId: segment.boxId,
+            kind: segment.kind,
+            sourceKind: segment.sourceKind,
+            origin: segment.origin,
+            editable: segment.editable,
+            startedAt: segment.startedAt,
+            endedAt: segment.endedAt,
+            trueStartedAt: segment.trueStartedAt,
+            trueEndedAt: segment.trueEndedAt,
+            visibleStartedAt: segment.visibleStartedAt,
+            visibleEndedAt: segment.visibleEndedAt,
+            durationSeconds: segment.durationSeconds,
+            label: segment.title,
+            subtitle: segment.subtitle,
+            distanceMeters: segment.distanceMeters,
+            averageSpeedMps: segment.averageSpeedMps,
+            estimatedScreenTimeSeconds,
+            pickupCount,
+            colorTone: segment.kind === "missing"
+                ? "from-slate-400/18 to-slate-600/10"
+                : segment.sourceKind === "user_defined"
+                    ? "from-rose-300/20 to-fuchsia-300/10"
+                    : segment.kind === "trip"
+                        ? "from-emerald-300/26 to-cyan-400/12"
+                        : segment.origin === "continued_stay"
+                            ? "from-sky-400/22 to-indigo-400/10"
+                            : "from-white/16 to-white/4",
+            noteCount,
+            overrideCount: segment.overrideCount,
+            overriddenAutomaticBoxIds: segment.overriddenAutomaticBoxIds,
+            overriddenUserBoxIds: segment.overriddenUserBoxIds,
+            isFullyHidden: segment.isFullyHidden,
+            rawStayIds: segment.rawStayIds,
+            rawTripIds: segment.rawTripIds,
+            rawPointCount: segment.rawPointCount,
+            hasLegacyCorrections: segment.hasLegacyCorrections
+        };
+    });
     const selectionAggregate = computeSelectionAggregate({
         startedAt: dayStart,
         endedAt: dayEnd,
@@ -2636,14 +4478,27 @@ export function getMovementDayDetail(input) {
         date: targetDate,
         settings: getMovementSettings(input.userIds),
         summary: {
-            totalDistanceMeters: round(trips.reduce((sum, trip) => sum + trip.distanceMeters, 0)),
-            totalMovingSeconds: trips.reduce((sum, trip) => sum + trip.movingSeconds, 0),
-            totalIdleSeconds: stays.reduce((sum, stay) => sum + stay.durationSeconds, 0) +
-                trips.reduce((sum, trip) => sum + trip.idleSeconds, 0),
-            tripCount: trips.length,
-            stayCount: stays.length,
+            totalDistanceMeters: round(allSegments.reduce((sum, segment) => sum + (segment.kind === "trip" ? segment.distanceMeters : 0), 0)),
+            totalMovingSeconds: allSegments.reduce((sum, segment) => sum + (segment.kind === "trip" ? segment.durationSeconds : 0), 0),
+            totalIdleSeconds: allSegments.reduce((sum, segment) => sum + (segment.kind === "stay" ? segment.durationSeconds : 0), 0),
+            tripCount: allSegments.filter((segment) => segment.kind === "trip").length,
+            stayCount: allSegments.filter((segment) => segment.kind === "stay").length,
+            missingCount: allSegments.filter((segment) => segment.kind === "missing").length,
+            missingDurationSeconds: allSegments
+                .filter((segment) => segment.kind === "missing")
+                .reduce((sum, segment) => sum + segment.durationSeconds, 0),
+            repairedGapCount: allSegments.filter((segment) => segment.origin === "repaired_gap").length,
+            repairedGapDurationSeconds: allSegments
+                .filter((segment) => segment.origin === "repaired_gap")
+                .reduce((sum, segment) => sum + segment.durationSeconds, 0),
+            continuedStayCount: allSegments.filter((segment) => segment.origin === "continued_stay").length,
+            continuedStayDurationSeconds: allSegments
+                .filter((segment) => segment.origin === "continued_stay")
+                .reduce((sum, segment) => sum + segment.durationSeconds, 0),
             knownPlaceCount: places.length,
             caloriesKcal: round(trips.reduce((sum, trip) => sum + (trip.caloriesKcal ?? 0), 0)),
+            estimatedScreenTimeSeconds: selectionAggregate.estimatedScreenTimeSeconds,
+            pickupCount: selectionAggregate.pickupCount,
             averageSpeedMps: round(average(trips
                 .map((trip) => trip.averageSpeedMps)
                 .filter((value) => typeof value === "number")), 2)
@@ -2788,7 +4643,7 @@ export function getMovementTripDetail(tripId) {
     const placesById = new Map(places.map((place) => [place.id, place]));
     const points = listTripPoints([tripId]);
     const stops = listTripStops([tripId]);
-    const trip = mapMovementTrip(tripRow, placesById, points, stops);
+    const trip = enrichMovementSegmentWithScreenTime(mapMovementTrip(tripRow, placesById, points, stops), [tripRow.user_id]);
     const stylizedPath = buildStylizedCurve(trip.points.map((point) => ({
         latitude: point.latitude,
         longitude: point.longitude
@@ -2930,6 +4785,10 @@ export function getMovementMobileBootstrap(pairing) {
         stayOverrides: stayRows.map((stay) => mapMovementStay(stay, placesById)),
         tripOverrides: tripRows.map((trip) => mapMovementTrip(trip, placesById, pointsByTrip.get(trip.id) ?? [], stopsByTrip.get(trip.id) ?? [])),
         deletedStayExternalUids: listMovementStayTombstones(pairing.user_id).map((row) => row.stay_external_uid),
-        deletedTripExternalUids: listMovementTripTombstones(pairing.user_id).map((row) => row.trip_external_uid)
+        deletedTripExternalUids: listMovementTripTombstones(pairing.user_id).map((row) => row.trip_external_uid),
+        projectedBoxes: getMovementTimeline({
+            userIds: [pairing.user_id],
+            limit: 80
+        }).segments
     };
 }