@remnic/core 9.65.7 → 9.66.0

package/src/lcm/summarizer.ts

@@ -1,8 +1,6 @@
-import { log } from "../logger.js";
-import { looksLikeMechanicalTelemetryTranscript } from "../telemetry-transcript.js";
-import { estimateTokenCount } from "../token-estimate.js";
-import type { LcmArchive, LcmMessage } from "./archive.js";
+import { summarizeContextPure, type SummarizeFn } from "../context-summary.js";
 import { estimateTokens } from "./archive.js";
+import type { LcmArchive, LcmMessage } from "./archive.js";
 import type { LcmDag } from "./dag.js";
 
 /** Generate a ULID-like ID (timestamp + random). */
@@ -12,11 +10,9 @@ function generateNodeId(): string {
   return `lcm-${ts}-${rand}`;
 }
 
-export type SummarizeFn = (
-  text: string,
-  targetTokens: number,
-  aggressive: boolean,
-) => Promise<string | null>;
+// `SummarizeFn` moved to the shared pure summary seam (context-summary.ts,
+// #2347); re-exported here for back-compat with existing imports.
+export type { SummarizeFn };
 
 export interface LcmSummarizerConfig {
   leafBatchSize: number;
@@ -145,98 +141,23 @@ export class LcmSummarizer {
   }
 
   /**
-   * Three-level escalation:
-   * 0 = Normal LLM summary
-   * 1 = Aggressive bullet compression
-   * 2 = Deterministic truncation (no LLM)
+   * Three-level escalation, delegated to the shared pure summary seam
+   * (context-summary.ts): 0 = normal LLM, 1 = aggressive, 2 = deterministic.
    */
   private async summarizeWithEscalation(
     text: string,
     targetTokens: number,
   ): Promise<{ text: string; escalation: number }> {
-    const { telemetryPrefilterEnabled } = this.config;
-    if (
-      telemetryPrefilterEnabled &&
-      looksLikeMechanicalTelemetryTranscript(text)
-    ) {
-      return {
-        text: deterministicTruncate(
-          text,
-          Math.min(targetTokens, this.config.deterministicMaxTokens),
-        ),
-        escalation: 2,
-      };
-    }
-
-    // Level 0: Normal LLM summary
-    try {
-      const result = await this.summarizeFn(text, targetTokens, false);
-      if (result && estimateTokens(result) <= targetTokens * 1.5) {
-        return { text: result, escalation: 0 };
-      }
-      // If too long, try aggressive
-    } catch (err) {
-      log.debug(`LCM level-0 summary failed: ${err}`);
-    }
-
-    // Level 1: Aggressive bullet compression
-    try {
-      const aggressiveTarget = Math.max(32, Math.ceil(targetTokens * 0.5));
-      const result = await this.summarizeFn(text, aggressiveTarget, true);
-      if (result && estimateTokens(result) <= targetTokens * 1.5) {
-        return { text: result, escalation: 1 };
-      }
-    } catch (err) {
-      log.debug(`LCM level-1 summary failed: ${err}`);
-    }
-
-    // Level 2: Deterministic truncation (guaranteed, no LLM)
-    return {
-      text: deterministicTruncate(text, this.config.deterministicMaxTokens),
-      escalation: 2,
-    };
-  }
-}
-
-/** Deterministic truncation: first and last sentence, plus middle truncation. */
-function deterministicTruncate(text: string, maxTokens: number): string {
-  if (maxTokens <= 0 || estimateTokenCount(text) <= maxTokens) return text;
-
-  const sentences = text.split(/(?<=[.!?])\s+/).filter((s) => s.length > 0);
-  if (sentences.length <= 2) return clampToTokenBudget(text, maxTokens);
-
-  const first = sentences[0];
-  const last = sentences[sentences.length - 1];
-  const render = (middle: string[], truncated: boolean): string =>
-    `${first} ${middle.join(" ")}${truncated ? " [...] " : " "}${last}`;
-
-  const base = render([], false);
-  if (estimateTokenCount(base) > maxTokens) return clampToTokenBudget(text, maxTokens);
-  if (estimateTokenCount(render([], true)) > maxTokens) return base;
-
-  const middle: string[] = [];
-  for (let i = 1; i < sentences.length - 1; i++) {
-    const candidate = [...middle, sentences[i]];
-    const truncated = i < sentences.length - 2;
-    if (estimateTokenCount(render(candidate, truncated)) > maxTokens) break;
-    middle.push(sentences[i]);
+    const { deterministicMaxTokens, telemetryPrefilterEnabled } = this.config;
+    const result = await summarizeContextPure(text, targetTokens, "auto", {
+      llm: this.summarizeFn,
+      deterministicMaxTokens,
+      telemetryPrefilterEnabled,
+    });
+    return { text: result.text, escalation: result.escalation ?? 2 };
   }
-
-  const truncated = middle.length < sentences.length - 2;
-  return clampToTokenBudget(render(middle, truncated), maxTokens);
 }
 
-function clampToTokenBudget(text: string, maxTokens: number): string {
-  const codePoints = [...text];
-  let low = 0;
-  let high = codePoints.length;
-  while (low < high) {
-    const mid = Math.ceil((low + high) / 2);
-    if (estimateTokenCount(codePoints.slice(0, mid).join("")) <= maxTokens) low = mid;
-    else high = mid - 1;
-  }
-  return codePoints.slice(0, low).join("");
-}
 
 function chunkArray<T>(arr: T[], size: number): T[][] {
   const chunks: T[][] = [];

package/src/location/access-operations.ts

@@ -9,8 +9,9 @@
 import { z } from "zod";
 import { defineOperation } from "../access-boundary.js";
 import type { EngramAccessService } from "../access-service.js";
+import { backfillMemoryStorage } from "./backfill.js";
 import {
-  parseLocationBackfillRange,
+  runLocationBackfill,
   runLocationCheck,
   runLocationDay,
   runLocationStatus,
@@ -21,9 +22,14 @@ import {
 /** Zod shape shared by the location operations (null-for-absent tolerant). */
 const dateField = z.union([z.string(), z.null()]).optional();
 const daysField = z.union([z.number(), z.string(), z.null()]).optional();
+const dryRunField = z.union([z.boolean(), z.null()]).optional();
 
 function locationDeps(service: EngramAccessService): LocationSurfaceDeps {
-  return { config: service.configRef.location, memoryDir: service.memoryDir };
+  return {
+    config: service.configRef.location,
+    memoryDir: service.memoryDir,
+    getMemoryStorage: () => backfillMemoryStorage(service.configRef),
+  };
 }
 
 defineOperation({
@@ -63,13 +69,16 @@ defineOperation({
 
 defineOperation({
   name: "location_backfill",
-  description: "Sync an explicit historical day range (≤ 90 days).",
+  description: "Sync an explicit historical day range (≤ 90 days) and re-tag overlapping memories (issue #2046).",
   fleetWide: true,
-  schema: z.object({ from: dateField, to: dateField }).passthrough(),
-  handler: async (input, ctx) => {
-    const range = parseLocationBackfillRange(input.from, input.to);
-    return { result: { days: await runLocationSync(locationDeps(ctx.service), range) } };
-  },
+  schema: z.object({ from: dateField, to: dateField, dryRun: dryRunField }).passthrough(),
+  handler: async (input, ctx) => ({
+    result: await runLocationBackfill(locationDeps(ctx.service), {
+      from: input.from ?? null,
+      to: input.to ?? null,
+      dryRun: input.dryRun === true,
+    }),
+  }),
 });
 
 defineOperation({

package/src/location/backfill.ts

@@ -0,0 +1,137 @@
+/**
+ * Location tag backfill (issue #2046) — idempotent, bounded, LLM-free.
+ *
+ * For each local day in an explicit [from, to] range, find the memories whose
+ * own bi-temporal window touches that day and re-run the shared tagging core
+ * over the stored location segments. Provider-owned fields update or remove
+ * as the (corrected) observations dictate; manual metadata, unrelated tags,
+ * supersession, corrections, and content hashes are untouched by the plan
+ * core in `matching.ts`.
+ *
+ * Failure isolation: one bad day is reported as `failed` and the run
+ * continues; one bad memory inside a day counts into `failed` without
+ * blocking its neighbors. A day with no stored segments is `emptyDay`, never
+ * an error (distinct from a failed day). Re-running the same range yields
+ * `unchanged` everywhere and writes nothing.
+ */
+
+import type { StorageManager } from "../index.js";
+import type { MemoryFile, PluginConfig } from "../types.js";
+import { resolveNamespaceCapabilities } from "../capabilities.js";
+import { resolveDefaultNamespaceRoot } from "../namespaces/storage.js";
+import { StorageManager as StorageManagerClass } from "../storage.js";
+import { localDayKey } from "./intervals.js";
+import { memoryLocationWindow } from "./matching.js";
+import {
+  emptyEnrichmentCounts,
+  enrichMemoriesWithLocation,
+  loadDaySegmentIndex,
+  locationTaggingEnabled,
+  type DaySegmentIndex,
+  type LocationEnrichmentCounts,
+} from "./tagging.js";
+import type { LocationConfig } from "./types.js";
+
+export interface LocationBackfillDayReport {
+  date: string;
+  /** No stored segments for any source on this day. */
+  emptyDay: boolean;
+  failed?: string;
+  counts: LocationEnrichmentCounts;
+  /** Memories whose window touched the day (empty days report 0). */
+  considered: number;
+}
+
+export interface LocationBackfillReport {
+  from: string;
+  to: string;
+  dryRun: boolean;
+  days: LocationBackfillDayReport[];
+}
+
+export interface BackfillLocationTagsOptions {
+  storage: Pick<StorageManager, "readAllMemories" | "getMemoryById" | "writeMemoryFrontmatter">;
+  memoryDir: string;
+  config: LocationConfig;
+  from: string;
+  to: string;
+  dryRun?: boolean;
+}
+
+export type BackfillMemoryStorage = Pick<StorageManager, "readAllMemories" | "getMemoryById" | "writeMemoryFrontmatter">;
+
+/**
+ * The memory store tag backfill patches: the default-namespace store — the
+ * root memory dir when namespaces are off, the resolved default-namespace
+ * root when they are on.
+ */
+export async function backfillMemoryStorage(config: PluginConfig): Promise<StorageManager> {
+  const root = resolveNamespaceCapabilities(config).namespaces
+    ? await resolveDefaultNamespaceRoot(config)
+    : config.memoryDir;
+  return new StorageManagerClass(root);
+}
+
+
+/** Memories whose own window touches `day`, in deterministic id order. */
+function memoriesTouchingDay(memories: readonly MemoryFile[], day: string, config: LocationConfig): MemoryFile[] {
+  const touched: MemoryFile[] = [];
+  for (const memory of memories) {
+    const result = memoryLocationWindow(memory.frontmatter, (instant) => localDayKey(instant, config.timezone));
+    if (result.days !== undefined && 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;
+}
+
+/**
+ * Run the bounded backfill. Requires both tagging gates (`location.enabled`
+ * and `location.tagging.enabled`); the caller surfaces a clear error for a
+ * gated-off run so no surface silently no-ops.
+ */
+export async function backfillLocationTags(
+  options: BackfillLocationTagsOptions,
+): Promise<LocationBackfillReport> {
+  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: DaySegmentIndex = await loadDaySegmentIndex(options.memoryDir);
+  const memories = await options.storage.readAllMemories();
+
+  const days: LocationBackfillDayReport[] = [];
+  const cursor = new Date(`${options.from}T00:00:00Z`);
+  const end = 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 === undefined || 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) {
+      // One failed day never blocks the rest of the range.
+      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 };
+}

package/src/location/config.test.ts

@@ -9,6 +9,9 @@ test("parseLocationConfig defaults to an inert configuration", () => {
     timezone: "UTC",
     syncDays: 1,
     retainCoordinates: false,
+    minimumOverlapSeconds: 300,
+    minimumConfidence: 0.7,
+    tagging: { enabled: false, backfillEnabled: false },
     sources: [],
   });
   assert.deepEqual(parseLocationConfig(undefined), defaultLocationConfig());

package/src/location/config.ts

@@ -1,6 +1,6 @@
 import { coerceBooleanLike, coerceNumber } from "../connectors/coerce.js";
 import { assertValidTimezone } from "../activity/digest.js";
-import type { LocationConfig, LocationSourceConfig } from "./types.js";
+import type { LocationConfig, LocationSourceConfig, LocationTaggingConfig } from "./types.js";
 
 const PROVIDER_ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 
@@ -11,6 +11,9 @@ export function defaultLocationConfig(): LocationConfig {
     timezone: "UTC",
     syncDays: 1,
     retainCoordinates: false,
+    minimumOverlapSeconds: 300,
+    minimumConfidence: 0.7,
+    tagging: { enabled: false, backfillEnabled: false },
     sources: [],
   };
 }
@@ -101,5 +104,46 @@ export function parseLocationConfig(raw: unknown): LocationConfig {
     throw new RangeError("location.enabled requires at least one source");
   }
 
-  return { enabled, timezone, syncDays, retainCoordinates, sources };
+  const overlapValue = coerceNumber(config.minimumOverlapSeconds, "location.minimumOverlapSeconds");
+  if (config.minimumOverlapSeconds !== undefined && overlapValue === undefined) {
+    throw new TypeError("location.minimumOverlapSeconds must be a finite number");
+  }
+  const minimumOverlapSeconds = overlapValue ?? 300;
+  if (!Number.isInteger(minimumOverlapSeconds) || minimumOverlapSeconds < 0) {
+    throw new RangeError("location.minimumOverlapSeconds must be an integer >= 0 (0 disables the floor)");
+  }
+
+  const confidenceValue = coerceNumber(config.minimumConfidence, "location.minimumConfidence");
+  if (config.minimumConfidence !== undefined && confidenceValue === undefined) {
+    throw new TypeError("location.minimumConfidence must be a finite number");
+  }
+  const minimumConfidence = confidenceValue ?? 0.7;
+  if (minimumConfidence < 0 || minimumConfidence > 1) {
+    throw new RangeError("location.minimumConfidence must be within [0, 1]");
+  }
+
+  const tagging = parseLocationTagging(config.tagging, enabled);
+
+  return { enabled, timezone, syncDays, retainCoordinates, minimumOverlapSeconds, minimumConfidence, tagging, sources };
+}
+
+function parseLocationTagging(raw: unknown, masterEnabled: boolean): LocationTaggingConfig {
+  if (raw === undefined || raw === null) return { enabled: false, backfillEnabled: false };
+  const tagging = asRecord(raw, "location.tagging");
+  const enabledValue = coerceBooleanLike(tagging.enabled, "location.tagging.enabled");
+  if (tagging.enabled !== undefined && enabledValue === undefined) {
+    throw new TypeError("location.tagging.enabled must be a boolean");
+  }
+  const backfillValue = coerceBooleanLike(tagging.backfillEnabled, "location.tagging.backfillEnabled");
+  if (tagging.backfillEnabled !== undefined && backfillValue === undefined) {
+    throw new TypeError("location.tagging.backfillEnabled must be a boolean");
+  }
+  const backfillEnabled = backfillValue ?? false;
+  if (enabledValue === true && !masterEnabled) {
+    throw new RangeError("location.tagging.enabled requires location.enabled");
+  }
+  if (backfillEnabled && !(enabledValue ?? false)) {
+    throw new RangeError("location.tagging.backfillEnabled requires location.tagging.enabled");
+  }
+  return { enabled: enabledValue ?? false, backfillEnabled };
 }

package/src/location/http-glue.ts

@@ -65,7 +65,7 @@ export async function respondLocationBackfill(
   service: EngramAccessService,
 ): Promise<void> {
   const output = (await requireLocationOperation("location_backfill").run(
-    { from: body.from ?? null, to: body.to ?? null },
+    { from: body.from ?? null, to: body.to ?? null, dryRun: body.dryRun === true },
     { service },
   )) as { result: unknown };
   respondJson(res, 200, output.result);

package/src/location/index.ts

@@ -8,6 +8,9 @@
  */
 
 export * from "./types.js";
+export * from "./matching.js";
+export * from "./tagging.js";
+export * from "./backfill.js";
 export * from "./registry.js";
 export * from "./config.js";
 export * from "./intervals.js";

package/src/location/intervals.ts

@@ -127,6 +127,7 @@ export function observationSegments(
       startUtc: new Date(currentMs).toISOString(),
       endUtc: new Date(segmentEndMs).toISOString(),
       place: placeForSegment(current.place, options.retainCoordinates),
+      ...(current.confidence !== undefined ? { confidence: current.confidence } : {}),
     });
   }
   return segments;

package/src/location/matching.test.ts

@@ -0,0 +1,65 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { matchDominantPlace, memoryLocationWindow, type LocationTagPolicy } from "./matching.js";
+import type { LocationPlace, LocationSegment } from "./types.js";
+
+const policy: LocationTagPolicy = {
+  minimumOverlapSeconds: 60,
+  minimumConfidence: 0.4,
+  retainCoordinates: false,
+};
+
+const home: LocationPlace = { id: "home", label: "Home", kind: "home" };
+const work: LocationPlace = { id: "work", label: "Work", kind: "work" };
+
+function segment(place: LocationPlace, start: string, end: string, confidence = 0.9): LocationSegment {
+  return { startUtc: start, endUtc: end, place, confidence };
+}
+
+test("untimed and over-long memories stay untagged", () => {
+  const day = (iso: string) => iso.slice(0, 10);
+  assert.equal(memoryLocationWindow({}, day).rejected, "untimed");
+  assert.equal(
+    memoryLocationWindow(
+      { valid_at: "2026-08-01T00:00:00.000Z", invalid_at: "2026-08-03T00:00:00.000Z" },
+      day,
+    ).rejected,
+    "span-too-long",
+  );
+});
+
+test("dominant named place wins; ties stay unmatched", () => {
+  const window = { kind: "interval" as const, startUtc: "2026-08-01T12:00:00.000Z", endUtc: "2026-08-01T14:00:00.000Z" };
+  const matched = matchDominantPlace(
+    window,
+    [
+      {
+        sourceId: "reitti",
+        segments: [
+          segment(home, "2026-08-01T11:00:00.000Z", "2026-08-01T13:30:00.000Z"),
+          segment(work, "2026-08-01T13:30:00.000Z", "2026-08-01T14:00:00.000Z"),
+        ],
+      },
+    ],
+    policy,
+  );
+  assert.equal(matched.status, "matched");
+  if (matched.status === "matched") assert.equal(matched.match.place.id, "home");
+
+  const tied = matchDominantPlace(
+    window,
+    [
+      {
+        sourceId: "reitti",
+        segments: [
+          segment(home, "2026-08-01T12:00:00.000Z", "2026-08-01T13:00:00.000Z"),
+          segment(work, "2026-08-01T13:00:00.000Z", "2026-08-01T14:00:00.000Z"),
+        ],
+      },
+    ],
+    policy,
+  );
+  assert.equal(tied.status, "unmatched");
+  if (tied.status === "unmatched") assert.equal(tied.reason, "ambiguous");
+});