@remnic/core 9.65.8 → 9.66.0

package/src/fallback-llm.test.ts

@@ -12,6 +12,70 @@ import {
   clearSecretCache,
 } from "./resolve-provider-secret.js";
 
+test("fallback llm sends native JSON schema to chat completions", { concurrency: false }, async () => {
+  clearModelsJsonCache();
+  clearSecretCache();
+  const llm = new FallbackLlmClient({
+    agents: { defaults: { model: { primary: "openai/test-model" } } },
+    models: { providers: { openai: { baseUrl: "https://openai.example/v1", api: "openai-completions", apiKey: "key", models: [] } } },
+  });
+  const originalFetch = globalThis.fetch;
+  let captured: Record<string, unknown> = {};
+  globalThis.fetch = (async (_url, init) => {
+    captured = JSON.parse(String(init?.body ?? "{}")) as Record<string, unknown>;
+    return new Response(JSON.stringify({ choices: [{ message: { content: '{"ok":true}' } }] }), { status: 200 });
+  }) as typeof fetch;
+  try {
+    await llm.chatCompletion([{ role: "user", content: "test" }], {
+      jsonSchema: { name: "test_result", schema: { type: "object", properties: { ok: { type: "boolean" } } }, strict: false },
+    });
+    assert.deepEqual(captured.response_format, {
+      type: "json_schema",
+      json_schema: {
+        name: "test_result",
+        strict: false,
+        schema: { type: "object", properties: { ok: { type: "boolean" } } },
+      },
+    });
+  } finally {
+    globalThis.fetch = originalFetch;
+    clearModelsJsonCache();
+    clearSecretCache();
+  }
+});
+
+test("fallback llm retries without native schema when the provider rejects it", { concurrency: false }, async () => {
+  clearModelsJsonCache();
+  clearSecretCache();
+  const llm = new FallbackLlmClient({
+    agents: { defaults: { model: { primary: "openai/test-model" } } },
+    models: { providers: { openai: { baseUrl: "https://openai.example/v1", api: "openai-completions", apiKey: "key", models: [] } } },
+  });
+  const originalFetch = globalThis.fetch;
+  const bodies: Array<Record<string, unknown>> = [];
+  globalThis.fetch = (async (_url, init) => {
+    const body = JSON.parse(String(init?.body ?? "{}")) as Record<string, unknown>;
+    bodies.push(body);
+    if (body.response_format) {
+      return new Response('response_format json_schema is unsupported', { status: 400 });
+    }
+    return new Response(JSON.stringify({ choices: [{ message: { content: '{"ok":true}' } }] }), { status: 200 });
+  }) as typeof fetch;
+  try {
+    const response = await llm.chatCompletion([{ role: "user", content: "test" }], {
+      jsonSchema: { name: "test_result", schema: { type: "object" } },
+    });
+    assert.equal(response?.content, '{"ok":true}');
+    assert.equal(bodies.length, 2);
+    assert.ok(bodies[0]?.response_format);
+    assert.equal(bodies[1]?.response_format, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    clearModelsJsonCache();
+    clearSecretCache();
+  }
+});
+
 test("fallback llm prefers the active gateway provider config over models.json", { concurrency: false }, async () => {
   __setModelsJsonForTest({
     "custom-provider": {
@@ -1711,3 +1775,73 @@ test("fallback llm redacts provider error bodies for sensitive calls", { concurr
 function disableGatewaySecretResolverForTest(): void {
   __setGatewayResolverForTest(async () => null);
 }
+
+test("fallback llm does not retry schema-stripping for unrelated unsupported errors", { concurrency: false }, async () => {
+  clearModelsJsonCache();
+  clearSecretCache();
+  const llm = new FallbackLlmClient({
+    agents: { defaults: { model: { primary: "openai/test-model" } } },
+    models: { providers: { openai: { baseUrl: "https://openai.example/v1", api: "openai-completions", apiKey: "key", models: [] } } },
+  });
+  const originalFetch = globalThis.fetch;
+  const bodies: Array<Record<string, unknown>> = [];
+  globalThis.fetch = (async (_url, init) => {
+    const body = JSON.parse(String(init?.body ?? "{}")) as Record<string, unknown>;
+    bodies.push(body);
+    // Unrelated provider error: "unsupported" without schema/format context.
+    return new Response(JSON.stringify({ error: { message: "'temperature' is unsupported with this model" } }), { status: 400 });
+  }) as typeof fetch;
+  try {
+    const response = await llm.chatCompletion([{ role: "user", content: "test" }], {
+      jsonSchema: { name: "test_result", schema: { type: "object" } },
+    });
+    assert.equal(response, null);
+    // Exactly one request: no schema-stripping duplicate for unrelated errors.
+    assert.equal(bodies.length, 1);
+  } finally {
+    globalThis.fetch = originalFetch;
+    clearModelsJsonCache();
+    clearSecretCache();
+  }
+});
+
+test("fallback llm retries without responsesJsonSchema when the Responses API rejects it and degrades the rest of the chain", { concurrency: false }, async () => {
+  clearModelsJsonCache();
+  clearSecretCache();
+  const llm = new FallbackLlmClient({
+    agents: { defaults: { model: { primary: "openai/test-model", fallbacks: ["openai/test-model-2"] } } },
+    models: { providers: { openai: { baseUrl: "https://openai.example/v1", api: "openai-responses", apiKey: "key", models: [] } } },
+  });
+  const originalFetch = globalThis.fetch;
+  const bodies: Array<Record<string, unknown>> = [];
+  globalThis.fetch = (async (_url, init) => {
+    const body = JSON.parse(String(init?.body ?? "{}")) as Record<string, unknown>;
+    bodies.push(body);
+    if ((body as { text?: { format?: unknown } }).text?.format) {
+      return new Response('text.format json_schema is unsupported', { status: 400 });
+    }
+    // Model 1 always fails content-wise; model 2 succeeds.
+    const model = String(body.model ?? "");
+    if (model.endsWith("test-model")) {
+      return new Response(JSON.stringify({ output_text: "not json" }), { status: 200 });
+    }
+    return new Response(JSON.stringify({ output_text: '{"ok":true}' }), { status: 200 });
+  }) as typeof fetch;
+  try {
+    const response = await llm.chatCompletion([{ role: "user", content: "test" }], {
+      responsesJsonSchema: { name: "test_result", schema: { type: "object" } },
+      acceptResponse: (r) => r.content.includes("ok"),
+    });
+    assert.ok(response?.content.includes("ok"));
+    // model1: schema attempt (rejected) + unstructured retry (bad output)
+    // model2: unstructured only — the schema must NOT be re-sent chain-wide.
+    assert.equal(bodies.length, 3);
+    assert.ok((bodies[0] as { text?: { format?: unknown } }).text?.format);
+    assert.equal((bodies[1] as { text?: { format?: unknown } }).text?.format, undefined);
+    assert.equal((bodies[2] as { text?: { format?: unknown } }).text?.format, undefined);
+  } finally {
+    globalThis.fetch = originalFetch;
+    clearModelsJsonCache();
+    clearSecretCache();
+  }
+});

package/src/fallback-llm.ts

@@ -27,6 +27,8 @@ export interface FallbackLlmOptions {
   store?: boolean;
   /** Request strict JSON output when a route uses the Responses API. */
   responsesJsonSchema?: { name: string; schema: Record<string, unknown> };
+  /** Request provider-native structured output on supported JSON transports. */
+  jsonSchema?: { name: string; schema: Record<string, unknown>; strict?: boolean };
   /** Hide provider error details that could echo private request content. */
   redactProviderErrors?: boolean;
   /** Explicit "provider/model" override to try before the configured chain. */
@@ -108,6 +110,22 @@ interface ModelRef {
   modelString: string;
 }
 
+function isUnsupportedJsonSchemaError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  // Require an HTTP status plus explicit schema/format context. A bare
+  // "unsupported" (e.g. "'temperature' is unsupported with this model") must
+  // NOT trigger the schema-stripping retry, or we pay a duplicate request
+  // for unrelated provider errors.
+  if (!/\b(?:400|404|422)\b/.test(message)) {
+    return false;
+  }
+  if (/(?:response[_ ]?format|json[_ ]?schema|structured[_ ]?output)/i.test(message)) {
+    return true;
+  }
+  // "unsupported" only counts when adjacent to schema/format terminology.
+  return /\bunsupported\b[\s\S]{0,40}\b(?:schema|format)\b/i.test(message);
+}
+
 const PROVIDER_ALIASES: Record<string, readonly string[]> = {
   "openai-codex": ["codex"],
   codex: ["openai-codex"],
@@ -199,8 +217,9 @@ export class FallbackLlmClient {
     }
 
     const runChain = async (
-      runOptions: FallbackLlmOptions,
+      initialOptions: FallbackLlmOptions,
     ): Promise<FallbackLlmResponse | null> => {
+      let runOptions = initialOptions;
       let lastRejectedResponse: FallbackLlmResponse | null = null;
       // Try each model in the chain
       for (let i = 0; i < models.length; i++) {
@@ -232,6 +251,47 @@ export class FallbackLlmClient {
           if (runOptions.signal?.aborted) {
             throw abortReason(runOptions.signal);
           }
+          if (
+            (runOptions.jsonSchema || runOptions.responsesJsonSchema) &&
+            isUnsupportedJsonSchemaError(err)
+          ) {
+            log.debug(`fallback LLM: ${model.modelString} rejected native JSON schema; retrying without it`);
+            // Degrade to prompt-only for the REST of the chain too, so an
+            // N-model chain where every provider rejects structured output
+            // costs N+1 requests instead of 2N.
+            runOptions = {
+              ...runOptions,
+              jsonSchema: undefined,
+              responsesJsonSchema: undefined,
+            };
+            try {
+              const result = await this.tryModel(model, messages, runOptions);
+              if (result) {
+                const response = {
+                  content: result.content,
+                  modelUsed: model.modelString,
+                  usage: result.usage,
+                };
+                if (!runOptions.acceptResponse || runOptions.acceptResponse(response)) {
+                  return response;
+                }
+                lastRejectedResponse = response;
+                log.debug(`fallback LLM: ${model.modelString} unstructured retry output rejected by acceptResponse, trying next model...`);
+                continue;
+              }
+            } catch (retryError) {
+              if (runOptions.signal?.aborted) throw abortReason(runOptions.signal);
+              const retryErrorMsg = runOptions.redactProviderErrors
+                ? "provider error details redacted"
+                : retryError instanceof Error
+                  ? retryError.message
+                  : String(retryError);
+              log.debug(
+                `fallback LLM: ${model.modelString} unstructured retry failed (${retryErrorMsg})`,
+              );
+            }
+            continue;
+          }
           const errorMsg = runOptions.redactProviderErrors
             ? "provider error details redacted"
             : err instanceof Error
@@ -736,6 +796,18 @@ export class FallbackLlmClient {
       ...buildChatCompletionTokenLimit(modelId, options.maxTokens ?? 4096, {
         assumeOpenAI,
       }),
+      ...(options.jsonSchema
+        ? {
+            response_format: {
+              type: "json_schema",
+              json_schema: {
+                name: options.jsonSchema.name,
+                strict: options.jsonSchema.strict ?? false,
+                schema: options.jsonSchema.schema,
+              },
+            },
+          }
+        : {}),
     };
 
     const response = await fetch(url, {
@@ -891,14 +963,14 @@ export class FallbackLlmClient {
         assumeOpenAI: shouldAssumeOpenAiChatCompletions(config.baseUrl),
       }),
       ...(options.store === undefined ? {} : { store: options.store }),
-      ...(options.responsesJsonSchema
+      ...(options.jsonSchema || options.responsesJsonSchema
         ? {
             text: {
               format: {
                 type: "json_schema",
-                name: options.responsesJsonSchema.name,
-                strict: true,
-                schema: options.responsesJsonSchema.schema,
+                name: (options.jsonSchema ?? options.responsesJsonSchema)!.name,
+                strict: (options.jsonSchema?.strict ?? (options.responsesJsonSchema ? true : false)),
+                schema: (options.jsonSchema ?? options.responsesJsonSchema)!.schema,
               },
             },
           }

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");
+});