@remnic/core 9.65.8 → 9.66.1

package/dist/{chunk-3BCULS4U.js → chunk-JKTV3JNX.js}

@@ -1,13 +1,32 @@
 import {
-  activityDayWindow,
-  isValidActivityDate
-} from "./chunk-M6L7HI7R.js";
+  resolveDefaultNamespaceRoot
+} from "./chunk-S4CDUXQY.js";
 import {
-  writeFileAtomically
-} from "./chunk-AW4QUFQF.js";
+  composeLocationDayBody,
+  composeLocationDayMeta,
+  emptyEnrichmentCounts,
+  enrichMemoriesWithLocation,
+  isValidLocationDate,
+  listLocationDayDates,
+  loadDaySegmentIndex,
+  loadLocationSyncState,
+  localDayKey,
+  locationDayWindow,
+  locationTaggingEnabled,
+  memoryLocationWindow,
+  observationSegments,
+  parseLocationDaySummary,
+  readLocationDay,
+  serializeLocationDay,
+  updateLocationSourceDay,
+  writeLocationDay
+} from "./chunk-TB2MJRI6.js";
 import {
-  pathIsInside
-} from "./chunk-GCASGYIO.js";
+  StorageManager
+} from "./chunk-2ITZ74A6.js";
+import {
+  resolveNamespaceCapabilities
+} from "./chunk-JUOZ62Y7.js";
 import {
   readEnvVar
 } from "./chunk-JUC24CTX.js";
@@ -56,472 +75,6 @@ function clearLocationProviders() {
   providers.clear();
 }
 
-// src/location/intervals.ts
-function isValidLocationDate(date) {
-  return isValidActivityDate(date);
-}
-function locationDayWindow(date, timezone) {
-  if (!isValidActivityDate(date)) {
-    throw new RangeError(`Invalid location date "${date}"; expected a real YYYY-MM-DD day.`);
-  }
-  return activityDayWindow(date, timezone);
-}
-function assertFiniteInstant(iso, what) {
-  const ms = Date.parse(iso);
-  if (typeof iso !== "string" || !Number.isFinite(ms)) {
-    throw new RangeError(`${what} must be a UTC ISO-8601 instant; got "${String(iso)}"`);
-  }
-  return ms;
-}
-function localDayKey(instantUtc, timezone) {
-  assertFiniteInstant(instantUtc, "instantUtc");
-  return new Intl.DateTimeFormat("en-CA", {
-    timeZone: timezone,
-    year: "numeric",
-    month: "2-digit",
-    day: "2-digit"
-  }).format(new Date(instantUtc));
-}
-function compareObservations(a, b) {
-  if (a.observedAtUtc !== b.observedAtUtc) {
-    return a.observedAtUtc < b.observedAtUtc ? -1 : 1;
-  }
-  if (a.place.id !== b.place.id) {
-    return a.place.id < b.place.id ? -1 : 1;
-  }
-  return 0;
-}
-function bucketObservationsByDay(observations, timezone) {
-  const buckets = /* @__PURE__ */ new Map();
-  for (const observation of observations) {
-    assertFiniteInstant(observation.observedAtUtc, "observation observedAtUtc");
-    const key = localDayKey(observation.observedAtUtc, timezone);
-    const bucket = buckets.get(key);
-    if (bucket === void 0) buckets.set(key, [observation]);
-    else bucket.push(observation);
-  }
-  for (const bucket of buckets.values()) bucket.sort(compareObservations);
-  return buckets;
-}
-function intervalOverlapMs(a, b) {
-  const overlap = Math.min(Date.parse(a.endUtc), Date.parse(b.endUtc)) - Math.max(Date.parse(a.startUtc), Date.parse(b.startUtc));
-  return Math.max(0, overlap);
-}
-function placeForSegment(place, retainCoordinates) {
-  if (retainCoordinates || place.latitude === void 0 || place.longitude === void 0) {
-    return place;
-  }
-  return {
-    id: place.id,
-    label: place.label,
-    ...place.kind === void 0 ? {} : { kind: place.kind }
-  };
-}
-function observationSegments(observations, window, options) {
-  const startMs = assertFiniteInstant(window.startUtc, "window startUtc");
-  const endMs = assertFiniteInstant(window.endUtc, "window endUtc");
-  if (startMs >= endMs) {
-    throw new RangeError("location window must satisfy startUtc < endUtc");
-  }
-  const ordered = [...observations].sort(compareObservations);
-  const segments = [];
-  for (let index = 0; index < ordered.length; index += 1) {
-    const current = ordered[index];
-    const currentMs = Date.parse(current.observedAtUtc);
-    if (currentMs < startMs || currentMs >= endMs) {
-      throw new RangeError(
-        `location observation at "${current.observedAtUtc}" falls outside the requested [${window.startUtc}, ${window.endUtc}) window`
-      );
-    }
-    const nextMs = index + 1 < ordered.length ? Date.parse(ordered[index + 1].observedAtUtc) : endMs;
-    const segmentEndMs = Math.min(nextMs, endMs);
-    if (currentMs >= segmentEndMs) continue;
-    segments.push({
-      startUtc: new Date(currentMs).toISOString(),
-      endUtc: new Date(segmentEndMs).toISOString(),
-      place: placeForSegment(current.place, options.retainCoordinates)
-    });
-  }
-  return segments;
-}
-function unionIntervalMs(segments) {
-  const bounds = segments.map((segment) => ({ start: Date.parse(segment.startUtc), end: Date.parse(segment.endUtc) })).sort((a, b) => a.start !== b.start ? a.start - b.start : a.end - b.end);
-  let total = 0;
-  let sweepStart = null;
-  let sweepEnd = 0;
-  for (const bound of bounds) {
-    if (sweepStart === null || bound.start > sweepEnd) {
-      if (sweepStart !== null) total += sweepEnd - sweepStart;
-      sweepStart = bound.start;
-      sweepEnd = bound.end;
-    } else if (bound.end > sweepEnd) {
-      sweepEnd = bound.end;
-    }
-  }
-  if (sweepStart !== null) total += sweepEnd - sweepStart;
-  return total;
-}
-function placeDurations(segments) {
-  const byPlace = /* @__PURE__ */ new Map();
-  for (const segment of segments) {
-    const existing = byPlace.get(segment.place.id);
-    if (existing === void 0) {
-      byPlace.set(segment.place.id, { place: segment.place, segments: [segment], firstStartUtc: segment.startUtc });
-      continue;
-    }
-    existing.segments.push(segment);
-    if (segment.startUtc < existing.firstStartUtc) existing.firstStartUtc = segment.startUtc;
-    if (segment.place.label < existing.place.label) existing.place = segment.place;
-  }
-  const durations = [...byPlace.values()].map((entry) => ({
-    place: entry.place,
-    totalMs: unionIntervalMs(entry.segments),
-    firstStartUtc: entry.firstStartUtc
-  }));
-  durations.sort((a, b) => {
-    if (a.place.id !== b.place.id) return a.place.id < b.place.id ? -1 : 1;
-    return 0;
-  });
-  return durations;
-}
-function dominantPlace(segments) {
-  const durations = placeDurations(segments);
-  let best = null;
-  for (const duration of durations) {
-    if (best === null) {
-      best = duration;
-      continue;
-    }
-    if (duration.totalMs !== best.totalMs) {
-      if (duration.totalMs > best.totalMs) best = duration;
-      continue;
-    }
-    if (duration.firstStartUtc !== best.firstStartUtc) {
-      if (duration.firstStartUtc < best.firstStartUtc) best = duration;
-      continue;
-    }
-    if (duration.place.id < best.place.id) best = duration;
-  }
-  return best === null ? null : { place: best.place, totalMs: best.totalMs };
-}
-
-// src/location/store.ts
-import { createHash } from "crypto";
-import { lstat, mkdir, readFile, readdir, realpath } from "fs/promises";
-import path from "path";
-var LOCATIONS_DIR_NAME = "locations";
-var LOCATION_DAY_KIND = "location-day";
-var LOCATION_DAY_FORMAT_VERSION = 1;
-var MAX_TRACKED_LOCATION_DAYS = 90;
-var DAY_FILE_NAME_PATTERN = /^\d{4}-\d{2}-\d{2}\.md$/;
-var stateLocks = /* @__PURE__ */ new Map();
-function withStateLock(key, fn) {
-  const prior = stateLocks.get(key) ?? Promise.resolve();
-  const next = prior.then(fn, fn);
-  const tail = next.then(
-    () => void 0,
-    () => void 0
-  );
-  stateLocks.set(key, tail);
-  void tail.then(() => {
-    if (stateLocks.get(key) === tail) stateLocks.delete(key);
-  });
-  return next;
-}
-function locationDayFilePath(memoryDir, date) {
-  if (!isValidLocationDate(date)) {
-    throw new RangeError(`Invalid location date "${date}"; expected a real YYYY-MM-DD day.`);
-  }
-  return path.join(memoryDir, LOCATIONS_DIR_NAME, `${date}.md`);
-}
-function locationSyncStateFilePath(memoryDir) {
-  return path.join(memoryDir, "state", "locations", "sync.json");
-}
-function emptyLocationSyncState() {
-  return { version: 1, sources: {} };
-}
-async function loadLocationSyncState(memoryDir) {
-  let raw;
-  try {
-    raw = await readFile(locationSyncStateFilePath(memoryDir), "utf-8");
-  } catch (err) {
-    if (err.code === "ENOENT") return emptyLocationSyncState();
-    throw err;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return emptyLocationSyncState();
-  }
-  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || typeof parsed.sources !== "object" || parsed.sources === null) {
-    return emptyLocationSyncState();
-  }
-  return { version: 1, sources: parsed.sources };
-}
-async function saveLocationSyncState(memoryDir, state) {
-  await mkdir(path.dirname(locationSyncStateFilePath(memoryDir)), { recursive: true, mode: 448 });
-  await writeFileAtomically(
-    locationSyncStateFilePath(memoryDir),
-    `${JSON.stringify(state, null, 2)}
-`
-  );
-}
-function pruneSourceDays(source) {
-  const days = source.days;
-  if (days === void 0) return;
-  const keys = Object.keys(days).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  for (const key of keys.slice(0, Math.max(0, keys.length - MAX_TRACKED_LOCATION_DAYS))) {
-    delete days[key];
-  }
-}
-async function updateLocationSourceDay(memoryDir, sourceId, date, payload, completedAtUtc) {
-  if (!isValidLocationDate(date)) {
-    throw new RangeError(`Invalid location date "${date}"; expected a real YYYY-MM-DD day.`);
-  }
-  return withStateLock(locationSyncStateFilePath(memoryDir), async () => {
-    const state = await loadLocationSyncState(memoryDir);
-    const source = state.sources[sourceId] ?? {};
-    const days = source.days ?? {};
-    days[date] = payload;
-    source.days = days;
-    source.lastSyncedAtUtc = completedAtUtc;
-    state.sources[sourceId] = source;
-    for (const candidate of Object.values(state.sources)) pruneSourceDays(candidate);
-    await saveLocationSyncState(memoryDir, state);
-    return state;
-  });
-}
-function hashLocationBody(body) {
-  return createHash("sha256").update(body, "utf8").digest("hex");
-}
-function clockHhMm(iso, timezone) {
-  return new Intl.DateTimeFormat("en-GB", {
-    timeZone: timezone,
-    hour: "2-digit",
-    minute: "2-digit",
-    hour12: false
-  }).format(new Date(iso));
-}
-function formatDuration(ms) {
-  const totalMinutes = Math.round(ms / 6e4);
-  const hours = Math.floor(totalMinutes / 60);
-  const minutes = totalMinutes % 60;
-  if (hours <= 0) return `${minutes}m`;
-  return `${hours}h ${String(minutes).padStart(2, "0")}m`;
-}
-function safeLabel(label) {
-  return label.replace(/\s+/g, " ").replace(/[`*_]/g, "").trim();
-}
-function formatPlaceLabel(segment) {
-  const label = safeLabel(segment.place.label);
-  return segment.place.kind === void 0 ? label : `${label} (${segment.place.kind})`;
-}
-function formatCoordinates(segment) {
-  if (segment.place.latitude === void 0 || segment.place.longitude === void 0) return "";
-  return ` @ ${segment.place.latitude.toFixed(4)},${segment.place.longitude.toFixed(4)}`;
-}
-function composeLocationDayBody(date, timezone, sources) {
-  const lines = [`# Location day \u2014 ${date} (${timezone})`, ""];
-  const allSegments = [];
-  let observationCount = 0;
-  for (const entry of Object.values(sources)) {
-    allSegments.push(...entry.segments);
-    observationCount += entry.observationCount;
-  }
-  lines.push("## Summary", "");
-  if (observationCount === 0) {
-    lines.push("No location observations recorded.", "");
-  } else {
-    const durations = placeDurations(allSegments).sort((a, b) => b.totalMs - a.totalMs);
-    lines.push(
-      `- Places visited: ${durations.length}`,
-      ...durations.map(
-        (duration) => `- ${safeLabel(duration.place.label)}: ${formatDuration(duration.totalMs)}`
-      ),
-      ""
-    );
-  }
-  const sourceIds = Object.keys(sources).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-  for (const sourceId of sourceIds) {
-    const entry = sources[sourceId];
-    lines.push(`## Timeline \u2014 ${safeLabel(entry.providerDisplayName ?? sourceId)}`, "");
-    if (entry.segments.length === 0) {
-      lines.push("No observations.", "");
-      continue;
-    }
-    for (const segment of entry.segments) {
-      lines.push(
-        `- ${clockHhMm(segment.startUtc, timezone)}\u2013${clockHhMm(segment.endUtc, timezone)} \u2014 ${formatPlaceLabel(segment)}${formatCoordinates(segment)}`
-      );
-    }
-    lines.push("");
-  }
-  return `${lines.join("\n").trimEnd()}
-`;
-}
-function composeLocationDayMeta(date, timezone, sources, body) {
-  let observationCount = 0;
-  for (const entry of Object.values(sources)) observationCount += entry.observationCount;
-  return {
-    kind: LOCATION_DAY_KIND,
-    date,
-    timezone,
-    formatVersion: LOCATION_DAY_FORMAT_VERSION,
-    sources: Object.keys(sources).sort((a, b) => a < b ? -1 : a > b ? 1 : 0),
-    observationCount,
-    contentHash: hashLocationBody(body)
-  };
-}
-function frontmatterScalar(key, value) {
-  return `${key}: ${typeof value === "number" ? value : JSON.stringify(value)}`;
-}
-function frontmatterList(key, values) {
-  if (values.length === 0) return [`${key}: []`];
-  const lines = [`${key}:`];
-  for (const value of values) lines.push(`  - ${JSON.stringify(value)}`);
-  return lines;
-}
-function serializeLocationDay(meta, body) {
-  const lines = ["---"];
-  lines.push(frontmatterScalar("kind", meta.kind));
-  lines.push(frontmatterScalar("date", meta.date));
-  lines.push(frontmatterScalar("timezone", meta.timezone));
-  lines.push(frontmatterScalar("formatVersion", meta.formatVersion));
-  lines.push(...frontmatterList("sources", meta.sources));
-  lines.push(frontmatterScalar("observationCount", meta.observationCount));
-  lines.push(frontmatterScalar("contentHash", meta.contentHash));
-  lines.push("---", "", body);
-  return lines.join("\n");
-}
-function parseScalar(raw) {
-  try {
-    const parsed = JSON.parse(raw);
-    return typeof parsed === "string" ? parsed : raw;
-  } catch {
-    return raw;
-  }
-}
-function parseLocationDaySummary(raw) {
-  if (!raw.startsWith("---\n")) return null;
-  const closeIndex = raw.indexOf("\n---\n", 4);
-  if (closeIndex === -1) return null;
-  const scalars = {};
-  const lists = {};
-  let currentList = null;
-  for (const line of raw.slice(4, closeIndex).split("\n")) {
-    const listItem = /^ {2}- (.*)$/.exec(line);
-    if (listItem !== null && currentList !== null) {
-      lists[currentList].push(parseScalar(listItem[1]));
-      continue;
-    }
-    currentList = null;
-    const separator = line.indexOf(":");
-    if (separator === -1) continue;
-    const key = line.slice(0, separator);
-    const value = line.slice(separator + 1).trim();
-    if (value === "" || value === "[]") {
-      lists[key] = [];
-      currentList = key;
-      continue;
-    }
-    if (value.startsWith("[")) {
-      lists[key] = [parseScalar(value)];
-      currentList = key;
-      continue;
-    }
-    scalars[key] = value;
-  }
-  if (scalars.kind === void 0 || parseScalar(scalars.kind) !== LOCATION_DAY_KIND) return null;
-  if (scalars.date === void 0 || scalars.contentHash === void 0) return null;
-  return {
-    date: parseScalar(scalars.date),
-    timezone: scalars.timezone === void 0 ? "UTC" : parseScalar(scalars.timezone),
-    sources: lists.sources ?? [],
-    observationCount: scalars.observationCount === void 0 ? 0 : Number(scalars.observationCount) || 0,
-    contentHash: parseScalar(scalars.contentHash)
-  };
-}
-function isErrnoCode(err, code) {
-  return err instanceof Error && err.code === code;
-}
-async function assertNotSymlink(target, kind) {
-  let stat;
-  try {
-    stat = await lstat(target);
-  } catch (err) {
-    if (isErrnoCode(err, "ENOENT")) return;
-    throw err;
-  }
-  if (stat.isSymbolicLink()) {
-    throw new Error(
-      `locations ${kind} '${path.basename(target)}' is a symbolic link \u2014 refusing to follow it even when it resolves inside the memory dir (AGENTS.md pattern #3)`
-    );
-  }
-}
-async function assertNoEscape(rootReal, candidate) {
-  let candidateReal;
-  try {
-    candidateReal = await realpath(candidate);
-  } catch {
-    return;
-  }
-  if (!pathIsInside(rootReal, candidateReal)) {
-    throw new Error(
-      "location day path resolves outside the memory dir \u2014 refusing to follow a symlink/traversal (AGENTS.md pattern #3)"
-    );
-  }
-}
-async function assertDayPathContained(memoryDir, targetPath) {
-  let rootReal;
-  try {
-    rootReal = await realpath(memoryDir);
-  } catch {
-    rootReal = path.resolve(memoryDir);
-  }
-  const locationsDir = path.join(memoryDir, LOCATIONS_DIR_NAME);
-  await assertNoEscape(rootReal, locationsDir);
-  await assertNoEscape(rootReal, targetPath);
-  await assertNotSymlink(locationsDir, "directory");
-  await assertNotSymlink(targetPath, "day file");
-}
-async function writeLocationDay(memoryDir, date, serialized) {
-  const target = locationDayFilePath(memoryDir, date);
-  await assertDayPathContained(memoryDir, target);
-  try {
-    if (await readFile(target, "utf-8") === serialized) return false;
-  } catch (err) {
-    if (!isErrnoCode(err, "ENOENT")) throw err;
-  }
-  await mkdir(path.dirname(target), { recursive: true, mode: 448 });
-  await writeFileAtomically(target, serialized);
-  return true;
-}
-async function readLocationDay(memoryDir, date) {
-  const target = locationDayFilePath(memoryDir, date);
-  await assertDayPathContained(memoryDir, target);
-  try {
-    return await readFile(target, "utf-8");
-  } catch (err) {
-    if (isErrnoCode(err, "ENOENT")) return null;
-    throw err;
-  }
-}
-async function listLocationDayDates(memoryDir) {
-  const locationsDir = path.join(memoryDir, LOCATIONS_DIR_NAME);
-  await assertDayPathContained(memoryDir, locationsDir);
-  let entries;
-  try {
-    entries = await readdir(locationsDir);
-  } catch (err) {
-    if (isErrnoCode(err, "ENOENT")) return [];
-    throw err;
-  }
-  const dates = entries.filter((entry) => DAY_FILE_NAME_PATTERN.test(entry)).map((entry) => entry.slice(0, -3));
-  dates.sort((a, b) => a > b ? -1 : a < b ? 1 : 0);
-  return dates;
-}
-
 // src/location/pipeline.ts
 var MAX_SYNC_PAGES = 1e4;
 function sanitizeProviderError(error) {
@@ -759,6 +312,63 @@ async function syncLocation(options) {
   return runs;
 }
 
+// src/location/backfill.ts
+async function backfillMemoryStorage(config) {
+  const root = resolveNamespaceCapabilities(config).namespaces ? await resolveDefaultNamespaceRoot(config) : config.memoryDir;
+  return new StorageManager(root);
+}
+function memoriesTouchingDay(memories, day, config) {
+  const touched = [];
+  for (const memory of memories) {
+    const result = memoryLocationWindow(memory.frontmatter, (instant) => localDayKey(instant, config.timezone));
+    if (result.days !== void 0 && result.days.includes(day)) touched.push(memory);
+  }
+  touched.sort((a, b) => a.frontmatter.id < b.frontmatter.id ? -1 : a.frontmatter.id > b.frontmatter.id ? 1 : 0);
+  return touched;
+}
+async function backfillLocationTags(options) {
+  if (!locationTaggingEnabled(options.config)) {
+    throw new Error(
+      "location backfill requires location.enabled and location.tagging.enabled (and location.tagging.backfillEnabled for the command surface)"
+    );
+  }
+  const index = await loadDaySegmentIndex(options.memoryDir);
+  const memories = await options.storage.readAllMemories();
+  const days = [];
+  const cursor = /* @__PURE__ */ new Date(`${options.from}T00:00:00Z`);
+  const end = /* @__PURE__ */ new Date(`${options.to}T00:00:00Z`);
+  while (cursor <= end) {
+    const date = cursor.toISOString().slice(0, 10);
+    try {
+      const daySegments = index.get(date);
+      if (daySegments === void 0 || daySegments.every((entry) => entry.segments.length === 0)) {
+        days.push({ date, emptyDay: true, counts: emptyEnrichmentCounts(), considered: 0 });
+      } else {
+        const touching = memoriesTouchingDay(memories, date, options.config);
+        const counts = await enrichMemoriesWithLocation({
+          storage: options.storage,
+          memoryDir: options.memoryDir,
+          config: options.config,
+          memories: touching,
+          index,
+          dryRun: options.dryRun === true
+        });
+        days.push({ date, emptyDay: false, counts, considered: touching.length });
+      }
+    } catch (error) {
+      days.push({
+        date,
+        emptyDay: false,
+        failed: error instanceof Error ? error.message : String(error),
+        counts: emptyEnrichmentCounts(),
+        considered: 0
+      });
+    }
+    cursor.setUTCDate(cursor.getUTCDate() + 1);
+  }
+  return { from: options.from, to: options.to, dryRun: options.dryRun === true, days };
+}
+
 // src/location/provider-setup.ts
 var loadFailuresWarned = /* @__PURE__ */ new Set();
 function readReittiEnv() {
@@ -862,7 +472,29 @@ function parseLocationBackfillRange(rawFrom, rawTo) {
   if (days > 90) {
     throw new EngramAccessInputError("location: backfill range is capped at 90 days");
   }
-  return { endDate: to, days };
+  return { from, endDate: to, days };
+}
+async function runLocationBackfill(deps, request = {}) {
+  const range = parseLocationBackfillRange(request.from, request.to);
+  if (!deps.config.enabled || !deps.config.tagging.enabled || !deps.config.tagging.backfillEnabled) {
+    throw new EngramAccessInputError(
+      "location: backfill requires location.enabled, location.tagging.enabled, and location.tagging.backfillEnabled"
+    );
+  }
+  await ensureConfiguredLocationProviders(deps.config);
+  const days = request.dryRun === true ? [] : await syncLocation({ ...deps, endDate: range.endDate, days: range.days });
+  let memory;
+  if (deps.getMemoryStorage !== void 0) {
+    memory = await backfillLocationTags({
+      storage: await deps.getMemoryStorage(),
+      memoryDir: deps.memoryDir,
+      config: deps.config,
+      from: range.from,
+      to: range.endDate,
+      dryRun: request.dryRun === true
+    });
+  }
+  return { days, ...memory !== void 0 ? { memory } : {} };
 }
 var USAGE = `Usage: location <command> [options]
 
@@ -873,8 +505,12 @@ Commands:
                                    ending yesterday)
     --date <YYYY-MM-DD>          End the window on this day (inclusive)
     --days <n>                   Window size, 1..90 (default: location.syncDays)
-  backfill --from <date> --to <date>
+  backfill --from <date> --to <date> [--dry-run]
                                  Sync an explicit historical range (\u2264 90 days)
+                                 and re-tag overlapping memories (requires
+                                 location.tagging.backfillEnabled). --dry-run
+                                 persists nothing: it only reports the memory
+                                 changes stored segments would produce.
   day <YYYY-MM-DD>               Print one stored location day
 
 Add --json to status/sync/backfill/day for machine-readable output.
@@ -882,7 +518,7 @@ Credentials for built-in providers come from the environment:
   reitti: REITTI_BASE_URL, REITTI_TOKEN[, REITTI_AUTH_MODE=x-api-token|bearer]
 `;
 var VALUE_FLAGS = /* @__PURE__ */ new Set(["--date", "--days", "--from", "--to"]);
-var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--json"]);
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set(["--json", "--dry-run"]);
 function parseCliFlags(args) {
   const flags = /* @__PURE__ */ new Map();
   const positional = [];
@@ -911,6 +547,25 @@ function parseCliFlags(args) {
   }
   return { flags, positional };
 }
+function renderBackfillReport(io, report) {
+  for (const day of report.days) {
+    if (day.emptyDay) {
+      io.stdout.write(`${day.date}: no stored location observations (empty day)
+`);
+      continue;
+    }
+    if (day.failed !== void 0) {
+      io.stdout.write(`${day.date}: FAILED \u2014 ${day.failed}
+`);
+      continue;
+    }
+    const c = day.counts;
+    io.stdout.write(
+      `${day.date}: ${c.tagged} tagged, ${c.updated} updated, ${c.removed} removed, ${c.unchanged} unchanged, ${c.unmatched} unmatched (incl. ambiguous), ${c.manual} manual, ${c.untimed} untimed, ${c.failed} failed, ${day.considered} considered${report.dryRun ? " (dry run)" : ""}
+`
+    );
+  }
+}
 function flagString(parsed, name) {
   const value = parsed.flags.get(name);
   return typeof value === "string" ? value : void 0;
@@ -1007,15 +662,20 @@ async function runLocationCliCommand(deps, args, io) {
       }
       case "backfill": {
         const parsed = parseCliFlags(rest);
-        const range = parseLocationBackfillRange(flagString(parsed, "--from"), flagString(parsed, "--to"));
-        const runs = await runLocationSync(deps, range);
+        const result = await runLocationBackfill(deps, {
+          from: flagString(parsed, "--from"),
+          to: flagString(parsed, "--to"),
+          dryRun: parsed.flags.has("--dry-run")
+        });
         if (parsed.flags.has("--json")) {
-          io.stdout.write(`${JSON.stringify({ days: runs }, null, 2)}
+          io.stdout.write(`${JSON.stringify(result, null, 2)}
 `);
         } else {
-          renderRuns(io, runs);
+          renderRuns(io, result.days);
+          if (result.memory !== void 0) renderBackfillReport(io, result.memory);
         }
-        return anySourceFailed(runs) ? 1 : 0;
+        const memoryFailed = result.memory?.days.some((day) => day.failed !== void 0) === true;
+        return anySourceFailed(result.days) || memoryFailed ? 1 : 0;
       }
       case "day": {
         const parsed = parseCliFlags(rest);
@@ -1052,42 +712,20 @@ export {
   getLocationProvider,
   listLocationProviders,
   clearLocationProviders,
-  isValidLocationDate,
-  locationDayWindow,
-  localDayKey,
-  bucketObservationsByDay,
-  intervalOverlapMs,
-  observationSegments,
-  placeDurations,
-  dominantPlace,
-  LOCATIONS_DIR_NAME,
-  LOCATION_DAY_KIND,
-  LOCATION_DAY_FORMAT_VERSION,
-  locationDayFilePath,
-  locationSyncStateFilePath,
-  emptyLocationSyncState,
-  loadLocationSyncState,
-  saveLocationSyncState,
-  updateLocationSourceDay,
-  hashLocationBody,
-  composeLocationDayBody,
-  composeLocationDayMeta,
-  serializeLocationDay,
-  parseLocationDaySummary,
-  writeLocationDay,
-  readLocationDay,
-  listLocationDayDates,
   sanitizeProviderError,
   syncLocationDay,
   locationStatus,
   checkLocationSources,
   syncLocation,
+  backfillMemoryStorage,
+  backfillLocationTags,
   ensureConfiguredLocationProviders,
   runLocationStatus,
   runLocationCheck,
   runLocationSync,
   runLocationDay,
   parseLocationBackfillRange,
+  runLocationBackfill,
   runLocationCliCommand
 };
-//# sourceMappingURL=chunk-3BCULS4U.js.map
+//# sourceMappingURL=chunk-JKTV3JNX.js.map