@remnic/core 9.69.41 → 9.69.42

package/src/location/phase5-wiring.test.ts

@@ -0,0 +1,408 @@
+/**
+ * Phase-5 wiring regression (issue #2925): the existing location subsystem
+ * feeding wearables, day summaries, and briefings — conservatively.
+ *
+ * Pins the contract the umbrella issue (#2043) requires:
+ *   - wearable location fill is missing-only and never overwrites a
+ *     source-provided value;
+ *   - conflicting / below-threshold overlaps stay untagged;
+ *   - absent, disabled, or unrequested location changes NOTHING (the
+ *     stored transcript body and gathered day summary are byte-identical);
+ *   - day summaries and briefings expose place names only behind the
+ *     explicit includeLocation request flag plus both location gates;
+ *   - labels only — coordinates never reach any phase-5 output.
+ */
+
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { test } from "node:test";
+
+import { StorageManager } from "../storage.js";
+import { WorkspaceOpsCoordinator, type WorkspaceOpsDeps } from "../orchestration/workspace-ops.js";
+import type { PluginConfig } from "../types.js";
+import type {
+  WearableConversation,
+  WearableSourceConnector,
+  WearableSourceSettings,
+  WearablesConfig,
+} from "../wearables/types.js";
+import { defaultWearableSourceSettings, defaultWearablesConfig } from "../wearables/config.js";
+import { parseDayTranscript } from "../wearables/day-store.js";
+import { syncWearableSource, type WearableSyncDeps } from "../wearables/pipeline.js";
+import { parseLocationConfig } from "./config.js";
+import { saveLocationSyncState } from "./store.js";
+import type { LocationConfig, LocationSegment } from "./types.js";
+import { briefingLocationSection } from "./tagging.js";
+
+const NOW = new Date("2026-06-11T03:00:00.000Z");
+
+function locationConfig(overrides: Record<string, unknown> = {}): LocationConfig {
+  return parseLocationConfig({
+    enabled: true,
+    timezone: "UTC",
+    sources: [{ id: "reitti" }],
+    tagging: { enabled: true },
+    ...overrides,
+  });
+}
+
+function segment(
+  startUtc: string,
+  endUtc: string,
+  label: string,
+  kind: LocationSegment["place"]["kind"] = "poi",
+): LocationSegment {
+  return {
+    startUtc,
+    endUtc,
+    place: {
+      id: `reitti:place:${label.toLowerCase().replace(/\s+/g, "-")}`,
+      label,
+      kind,
+      latitude: 60.1699,
+      longitude: 24.9384,
+    },
+    confidence: 0.9,
+  };
+}
+
+async function seedLocationDays(memoryDir: string, days: Record<string, LocationSegment[]>) {
+  await saveLocationSyncState(memoryDir, {
+    version: 1,
+    sources: {
+      reitti: {
+        days: Object.fromEntries(
+          Object.entries(days).map(([date, segments]) => [
+            date,
+            { observationCount: segments.length, segments },
+          ]),
+        ),
+      },
+    },
+  });
+}
+function wearableSettings(): WearableSourceSettings {
+  return { ...defaultWearableSourceSettings(), enabled: true };
+}
+
+function wearablesConfig(timezone = "UTC"): WearablesConfig {
+  return {
+    ...defaultWearablesConfig(),
+    enabled: true,
+    timezone,
+    digestEnabled: false,
+    offTheRecordEnabled: false,
+  };
+}
+
+function conversation(
+  id: string,
+  startIso: string,
+  endIso: string,
+  overrides: Partial<WearableConversation> = {},
+): WearableConversation {
+  return {
+    id,
+    source: "testsource",
+    title: `Conversation ${id}`,
+    startIso,
+    endIso,
+    segments: [{ speakerKey: "user", speakerName: "user", isWearer: true, text: "Synthetic wearable text." }],
+    ...overrides,
+  };
+}
+
+function fakeConnector(byDate: Record<string, WearableConversation[]>): WearableSourceConnector {
+  return {
+    id: "testsource",
+    displayName: "Test Source",
+    async verifyAuth() {
+      return { ok: true };
+    },
+    async fetchConversations(opts: { date: string }) {
+      return { conversations: byDate[opts.date] ?? [], nextCursor: null };
+    },
+  };
+}
+
+function makeSyncDeps(
+  memoryDir: string,
+  now: Date,
+  locationConfigValue?: LocationConfig,
+): { deps: WearableSyncDeps; written: Array<{ source: string; date: string; serialized: string }> } {
+  const written: Array<{ source: string; date: string; serialized: string }> = [];
+  const deps: WearableSyncDeps = {
+    memoryDir,
+    async readDayContentHash() {
+      return null;
+    },
+    writeDayTranscript(source, date, serialized) {
+      written.push({ source, date, serialized });
+      return Promise.resolve();
+    },
+    memoryGen: null,
+    now: () => now,
+    ...(locationConfigValue !== undefined ? { locationConfig: locationConfigValue } : {}),
+  };
+  return { deps, written };
+}
+
+function bodyOf(serialized: string): string {
+  const parsed = parseDayTranscript(serialized);
+  assert.ok(parsed, "day transcript parses");
+  return parsed.body;
+}
+
+// ── Wearable fill ───────────────────────────────────────────────────────────
+
+test("wearable sync fills only missing conversation locations from a dominant overlap", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-phase5-fill-"));
+  try {
+    await seedLocationDays(memoryDir, {
+      "2026-06-11": [segment("2026-06-11T14:30:00.000Z", "2026-06-11T16:00:00.000Z", "Coffee shop")],
+    });
+    const { deps, written } = makeSyncDeps(memoryDir, NOW, locationConfig());
+    const connector = fakeConnector({
+      "2026-06-11": [
+        conversation("c-missing", "2026-06-11T15:00:00.000Z", "2026-06-11T15:30:00.000Z"),
+        conversation("c-source", "2026-06-11T15:00:00.000Z", "2026-06-11T15:30:00.000Z", {
+          location: "Office rooftop",
+        }),
+      ],
+    });
+
+    await syncWearableSource(connector, wearableSettings(), wearablesConfig(), { days: 1 }, deps);
+
+    assert.equal(written.length, 1, "day transcript written");
+    const body = bodyOf(written[0].serialized);
+    assert.ok(body.includes("*Location: Coffee shop*"), "missing location filled from the dominant match");
+    const sourceSection = body.slice(body.indexOf("Conversation c-source"));
+    assert.ok(sourceSection.includes("*Location: Office rooftop*"), "source-provided location kept");
+    assert.ok(!sourceSection.includes("Coffee shop"), "source-provided value not overwritten");
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("conflicting and below-threshold overlaps leave wearable locations unfilled", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-phase5-threshold-"));
+  try {
+    await seedLocationDays(memoryDir, {
+      // Two equal-overlap places → ambiguous (conflict).
+      "2026-06-11": [
+        segment("2026-06-11T15:00:00.000Z", "2026-06-11T15:15:00.000Z", "Diner"),
+        segment("2026-06-11T15:15:00.000Z", "2026-06-11T15:30:00.000Z", "Gym"),
+      ],
+      // A 2-minute overlap only → below the 300s floor.
+      "2026-06-12": [segment("2026-06-12T15:28:00.000Z", "2026-06-12T16:30:00.000Z", "Library")],
+    });
+    const { deps, written } = makeSyncDeps(memoryDir, new Date("2026-06-12T03:00:00.000Z"), locationConfig());
+    const connector = fakeConnector({
+      "2026-06-11": [conversation("c-ambiguous", "2026-06-11T15:00:00.000Z", "2026-06-11T15:30:00.000Z")],
+      "2026-06-12": [conversation("c-short", "2026-06-12T15:00:00.000Z", "2026-06-12T15:30:00.000Z")],
+    });
+
+    await syncWearableSource(connector, wearableSettings(), wearablesConfig(), { days: 2 }, deps);
+
+    assert.equal(written.length, 2, "both days written");
+    const bodies = written.map((entry) => bodyOf(entry.serialized));
+    assert.ok(
+      !bodies.some((body) => body.includes("*Location:")),
+      `no location line written: ${bodies.join("\n---\n")}`,
+    );
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("wearable sync output is byte-identical without location config or with tagging disabled", async () => {
+  const run = async (locationConfigValue?: LocationConfig) => {
+    const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-phase5-zerodiff-"));
+    try {
+      if (locationConfigValue) {
+        await seedLocationDays(memoryDir, {
+          "2026-06-11": [segment("2026-06-11T14:30:00.000Z", "2026-06-11T16:00:00.000Z", "Coffee shop")],
+        });
+      }
+      const { deps, written } = makeSyncDeps(memoryDir, NOW, locationConfigValue);
+      const connector = fakeConnector({
+        "2026-06-11": [conversation("c1", "2026-06-11T15:00:00.000Z", "2026-06-11T15:30:00.000Z")],
+      });
+      await syncWearableSource(connector, wearableSettings(), wearablesConfig(), { days: 1 }, deps);
+      assert.equal(written.length, 1);
+      return bodyOf(written[0].serialized);
+    } finally {
+      rmSync(memoryDir, { recursive: true, force: true });
+    }
+  };
+
+  const baseline = await run(undefined);
+  const disabled = await run(locationConfig({ tagging: { enabled: false } }));
+  assert.equal(disabled, baseline, "tagging disabled → identical transcript body");
+  assert.ok(!baseline.includes("*Location:"), "no location line by default");
+});
+
+test("wearable fill resolves the day bucket across a midnight boundary in the location timezone", async () => {
+  const memoryDir = mkdtempSync(path.join(tmpdir(), "remnic-phase5-midnight-"));
+  try {
+    // America/New_York: conversation 2026-06-30T03:30Z–04:30Z is
+    // 23:30–00:30 local, spanning the June-29 / June-30 midnight. The only
+    // qualifying segment (00:00–01:00 local) lives on the June-30 bucket —
+    // the conversation's END-anchored day, not its start day. The fill must
+    // consult both day keys, not just the start day.
+    const nyConfig = locationConfig({ timezone: "America/New_York" });
+    await seedLocationDays(memoryDir, {
+      "2026-06-30": [segment("2026-06-30T04:00:00.000Z", "2026-06-30T05:00:00.000Z", "Late diner")],
+    });
+    const { deps, written } = makeSyncDeps(memoryDir, new Date("2026-07-01T03:00:00.000Z"), nyConfig);
+    const connector = fakeConnector({
+      "2026-06-30": [conversation("c-span", "2026-06-30T03:30:00.000Z", "2026-06-30T04:30:00.000Z")],
+    });
+
+    await syncWearableSource(
+      connector,
+      wearableSettings(),
+      wearablesConfig("America/New_York"),
+      { date: "2026-06-30" },
+      deps,
+    );
+
+    assert.equal(written.length, 1);
+    const body = bodyOf(written[0].serialized);
+    assert.ok(body.includes("*Location: Late diner*"), `cross-midnight segment matched: ${body}`);
+  } finally {
+    rmSync(memoryDir, { recursive: true, force: true });
+  }
+});
+
+// ── Day summary opt-in ──────────────────────────────────────────────────────
+
+function opsCoordinator(storage: StorageManager, configOverrides: Partial<PluginConfig>) {
+  return new WorkspaceOpsCoordinator({
+    config: {
+      defaultNamespace: "default",
+      daySummaryTimezone: "UTC",
+      ...configOverrides,
+    } as unknown as PluginConfig,
+    storageRouter: {
+      storageFor: async () => storage,
+    },
+  } as unknown as WorkspaceOpsDeps);
+}
+
+test("gatherTodayFacts appends location context only when requested and gated", async () => {
+  const gather = async (options: { includeLocation?: boolean; location?: LocationConfig }) => {
+    const root = mkdtempSync(path.join(tmpdir(), "remnic-phase5-summary-"));
+    try {
+      const storage = new StorageManager(root);
+      await storage.writeMemory("fact", "Shipped the location wiring.", { source: "test" });
+      if (options.location) {
+        const day = new Date().toISOString().slice(0, 10);
+        await seedLocationDays(root, {
+          [day]: [segment(`${day}T09:00:00.000Z`, `${day}T17:00:00.000Z`, "Office", "work")],
+        });
+      }
+      const coordinator = opsCoordinator(storage, options.location ? { location: options.location } : {});
+      return await coordinator.gatherTodayFacts(undefined, {
+        now: new Date(),
+        timeZone: "UTC",
+        ...(options.includeLocation !== undefined ? { includeLocation: options.includeLocation } : {}),
+      });
+    } finally {
+      rmSync(root, { recursive: true, force: true });
+    }
+  };
+
+  // Each gather run writes a fresh fact id/timestamp header; normalize it
+  // away so byte-comparisons isolate the location delta.
+  const normalized = (gathered: string) => gathered.replace(/^\[fact-[^\]]*\] \([^)]*\)/gm, "[fact]");
+
+  const enabled = locationConfig();
+  const baseline = await gather({});
+  const withStateNoFlag = await gather({ location: enabled });
+  assert.equal(normalized(withStateNoFlag), normalized(baseline), "no request flag → byte-identical gathered summary");
+
+  const withFlagNoState = await gather({ includeLocation: true });
+  assert.equal(normalized(withFlagNoState), normalized(baseline), "flag without location state → byte-identical");
+
+  const withFlag = await gather({ includeLocation: true, location: enabled });
+  assert.ok(withFlag.includes("## Location context"), "opt-in adds the location section");
+  assert.ok(withFlag.includes("- Office: 8h 00m"), "labels and durations only");
+
+  const flagButTaggingOff = await gather({
+    includeLocation: true,
+    location: locationConfig({ tagging: { enabled: false } }),
+  });
+  assert.equal(normalized(flagButTaggingOff), normalized(baseline), "flag with tagging disabled → byte-identical");
+});
+
+// ── Briefing opt-in ─────────────────────────────────────────────────────────
+
+test("briefingLocationSection is opt-in, start-day anchored, and labels-only", async () => {
+  const root = mkdtempSync(path.join(tmpdir(), "remnic-phase5-briefing-"));
+  try {
+    const day = new Date().toISOString().slice(0, 10);
+    await seedLocationDays(root, {
+      [day]: [
+        segment(`${day}T08:00:00.000Z`, `${day}T18:00:00.000Z`, "HQ", "work"),
+        segment(`${day}T18:00:00.000Z`, `${day}T19:00:00.000Z`, "Commuter rail", "transit"),
+      ],
+    });
+
+    const gatedOff = await briefingLocationSection(
+      root,
+      new Date().toISOString(),
+      locationConfig({ tagging: { enabled: false } }),
+    );
+    assert.equal(gatedOff, null, "tagging disabled → no section");
+
+    const section = await briefingLocationSection(root, new Date().toISOString(), locationConfig());
+    assert.ok(section, "gated on → section rendered");
+    assert.ok(section.includes("## Location context"));
+    assert.ok(section.includes("- HQ: 10h 00m"), "work place rendered with duration");
+    assert.ok(!section.includes("Commuter rail"), "transit-only place excluded");
+
+    const none = await briefingLocationSection(
+      root,
+      new Date(Date.now() - 90 * 24 * 3600 * 1000).toISOString(),
+      locationConfig(),
+    );
+    assert.equal(none, null, "window start on a day without segments → no section");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});
+
+// ── Privacy ─────────────────────────────────────────────────────────────────
+
+test("phase-5 outputs never contain coordinates or raw location records", async () => {
+  const root = mkdtempSync(path.join(tmpdir(), "remnic-phase5-privacy-"));
+  try {
+    const day = new Date().toISOString().slice(0, 10);
+    // Segment places carry coordinates (as if retainCoordinates had been on
+    // at ingestion) — every phase-5 surface must still render labels only.
+    await seedLocationDays(root, {
+      [day]: [segment(`${day}T08:00:00.000Z`, `${day}T18:00:00.000Z`, "HQ", "work")],
+    });
+
+    const section = await briefingLocationSection(root, new Date().toISOString(), locationConfig());
+    assert.ok(section);
+    assert.ok(!/\d+\.\d{3,}/.test(section), `no coordinate-like numbers: ${section}`);
+    assert.ok(!section.includes("startUtc") && !section.includes("observationCount"), "no raw record fields");
+
+    const storage = new StorageManager(root);
+    await storage.writeMemory("fact", "Privacy probe fact.", { source: "test" });
+    const coordinator = opsCoordinator(storage, { location: locationConfig() });
+    const gathered = await coordinator.gatherTodayFacts(undefined, {
+      now: new Date(),
+      timeZone: "UTC",
+      includeLocation: true,
+    });
+    assert.ok(!gathered.includes("60.1699") && !gathered.includes("24.9384"), "no coordinates in day-summary input");
+    assert.ok(!gathered.includes("latitude") && !gathered.includes("longitude"), "no coordinate field names");
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/location/tagging.ts

@@ -275,3 +275,61 @@ export async function renderDayLocationContext(
   });
   return `## Location context\n\n${lines.join("\n")}`;
 }
+
+/**
+ * Location context for a briefing (issue #2925): the place names of the
+ * local day containing the briefing window's start, bucketed in the
+ * location config's own timezone (the store's bucketing zone). Opt-in and
+ * labels-only — the caller decides whether to include it.
+ */
+export async function briefingLocationSection(
+  memoryDir: string,
+  windowStartUtc: string,
+  config: LocationConfig,
+): Promise<string | null> {
+  return renderDayLocationContext(
+    memoryDir,
+    localDayKey(windowStartUtc, config.timezone),
+    config,
+  );
+}
+
+export async function applyBriefingLocationContext<
+  T extends { markdown: string; json: Record<string, unknown> },
+>(
+  result: T,
+  includeLocation: boolean | undefined,
+  memoryDir: string,
+  windowStartUtc: string,
+  location: LocationConfig,
+): Promise<T> {
+  if (includeLocation !== true || !locationTaggingEnabled(location)) return result;
+  const section = await briefingLocationSection(memoryDir, windowStartUtc, location);
+  if (!section) return result;
+  return {
+    ...result,
+    markdown: `${result.markdown}\n\n${section}\n`,
+    json: { ...result.json, locationContext: section },
+  };
+}
+
+/**
+ * Opt-in matched-place-name context (issue #2925), shared by the access
+ * request surfaces (day summary and briefing). Absent or false keeps the
+ * output byte-identical.
+ */
+export interface LocationContextRequestOptions {
+  /** Opt-in matched-place-name context appended to the summary or briefing output. */
+  includeLocation?: boolean;
+}
+
+/**
+ * Auto-gather options for the day summary (issue #2925): the caller's
+ * timezone plus the strictly-opt-in location flag. Only the literal
+ * `true` opts in, matching the transport schemas' boolean contract.
+ */
+export function daySummaryAutoOptions(
+  request: LocationContextRequestOptions & { timeZone?: string },
+): { timeZone?: string; includeLocation: boolean } {
+  return { timeZone: request.timeZone, includeLocation: request.includeLocation === true };
+}

package/src/orchestration/orchestrator-helpers.ts

@@ -325,6 +325,8 @@ export const DEFAULT_QMD_STARTUP_COLLECTION_CHECK_TIMEOUT_MS = 10_000;
 export type DaySummaryGatherOptions = {
   timeZone?: string;
   now?: Date;
+  /** Opt-in location context (issue #2925); false/absent keeps output byte-identical. */
+  includeLocation?: boolean;
 };
 
 export function normalizeIanaTimeZone(value: unknown): string | undefined {

package/src/orchestration/workspace-ops.ts

@@ -28,6 +28,8 @@ import { LocalLlmClient } from "../local-llm.js";
 import { log } from "../logger.js";
 import type { NamespaceMaintenanceFanoutRunnerContext } from "../maintenance/namespace-maintenance-fanout.js";
 import type { NamespaceMaintenanceSummary } from "../maintenance/namespace-planner.js";
+import { localDayKey } from "../location/intervals.js";
+import { renderDayLocationContext } from "../location/tagging.js";
 import { type PatternReinforcementResult, runPatternReinforcement } from "../maintenance/pattern-reinforcement.js";
 import { evaluateMemoryActionPolicy } from "../memory-action-policy.js";
 import { NamespaceStorageRouter } from "../namespaces/storage.js";
@@ -454,6 +456,17 @@ export class WorkspaceOpsCoordinator {
       }
     }
 
+    if (options.includeLocation === true && this.deps.config.location) {
+      const section = await renderDayLocationContext(
+        storage.dir,
+        localDayKey(now.toISOString(), this.deps.config.location.timezone),
+        this.deps.config.location,
+      );
+      if (section) {
+        formatted += `\n\n${section}`;
+      }
+    }
+
     log.info(
       `gatherTodayFacts: collected ${facts.length} facts, ${hourlySummaries.length} hourly summaries for ${targetLocalDate} (${timeZone}, ${formatted.length} chars)`,
     );
@@ -636,6 +649,7 @@ export class WorkspaceOpsCoordinator {
       service = new WearablesService({
         config: this.deps.config.wearables,
         getStorage: async () => await this.deps.getStorageForNamespace(namespace),
+        locationConfig: this.deps.config.location,
         extract: (turns) => this.deps.extraction.extract(turns),
         // Smart memoryMode runs candidates through the SAME extraction
         // judge (cache + defer counters included) the live extraction

package/src/wearables/pipeline.ts

@@ -15,6 +15,7 @@
  * write for the run has succeeded.
  */
 
+import { fillWearableConversationLocations } from "../location/tagging.js";
 import { cleanConversation } from "./cleanup.js";
 import { describeErrorForOperator, WearablesInputError } from "./errors.js";
 import {
@@ -50,6 +51,7 @@ import {
   saveSyncState,
   updateSourceSyncState,
 } from "./sync-state.js";
+import type { LocationConfig } from "../location/types.js";
 import type {
   WearableConversation,
   WearableSourceConnector,
@@ -122,6 +124,11 @@ export interface WearableSyncDeps {
   listSupportMemories?(): Promise<Array<{ id: string; content: string }>>;
   /** Clock injection for tests. */
   now?: () => Date;
+  /**
+   * Location config for the missing-only conversation location fill
+   * (issue #2925). Absent, or location tagging disabled, changes nothing.
+   */
+  locationConfig?: LocationConfig;
 }
 
 /** Format a Date as YYYY-MM-DD in the given IANA timezone. */
@@ -382,6 +389,18 @@ export async function syncWearableSource(
     summary.redactions += cleaned.redactions;
     summary.correctionsApplied += cleaned.correctionsApplied;
 
+    // Missing-only location fill (issue #2925): run before the body is
+    // composed so a qualifying dominant-overlap place reaches the day
+    // transcript and memory headers exactly like a provider-supplied
+    // location would. Source-provided values are never overwritten, and
+    // the helper no-ops unless both location gates are on.
+    if (deps.locationConfig) {
+      await fillWearableConversationLocations(cleaned.conversations, {
+        memoryDir: deps.memoryDir,
+        config: deps.locationConfig,
+      });
+    }
+
     if (fetched.conversations.length === 0) {
       // No provider data at all. A transient provider hiccup can
       // legitimately produce an empty result, so an existing stored

package/src/wearables/service.ts

@@ -13,6 +13,7 @@ import {
 } from "./corrections.js";
 import { describeErrorForOperator, WearablesInputError } from "./errors.js";
 import { inferMemoryStatus } from "../memory-lifecycle-ledger-utils.js";
+import type { LocationConfig } from "../location/types.js";
 import { isSupportPassportPrivateMemory } from "../support-passport/card-projection.js";
 import {
   bodyIsEscaped,
@@ -143,6 +144,12 @@ export interface WearablesServiceDeps {
    * fails the sync.
    */
   onDaysSynced?: (days: readonly string[]) => void | Promise<void>;
+  /**
+   * Location config for the missing-only conversation location fill
+   * (issue #2925). Absent changes nothing; the fill itself stays gated
+   * on the location tagging flags.
+   */
+  locationConfig?: LocationConfig;
 }
 
 export interface WearableTranscriptSearchResult {
@@ -351,6 +358,7 @@ export class WearablesService {
         options,
         {
           memoryDir: storage.dir,
+          locationConfig: this.deps.locationConfig,
           readDayContentHash: async (source, date) => {
             const raw = await storage.readWearableDayTranscript(source, date);
             if (raw === null) return null;