@remnic/core 9.69.41 → 9.69.43

package/src/cli/recall-navigation-commands.ts

@@ -0,0 +1,85 @@
+/**
+ * Recall-navigation command group (issue #1956) — extracted from cli.ts so
+ * the surface file stays at its structural ceiling (same seam as
+ * deep-recall-commands.ts). `remnic navigate expand|traverse <memoryId>`
+ * runs through EngramAccessService.recallNavigate — the same single
+ * implementation MCP and HTTP call, sharing one renderer.
+ */
+
+import type { Orchestrator } from "../orchestrator.js";
+import type { CliCommand } from "../cli.js";
+import { EngramAccessService } from "../access-service.js";
+
+function parseLimit(raw: unknown): number | undefined {
+  if (raw === undefined || raw === null) return undefined;
+  const value = typeof raw === "string" ? Number(raw) : raw;
+  if (typeof value !== "number" || !Number.isFinite(value) || !Number.isInteger(value) || value < 1) {
+    throw new Error(`--limit must be a positive integer; got ${JSON.stringify(raw)}`);
+  }
+  return value;
+}
+
+export function registerRecallNavigationCommands(cmd: CliCommand, orchestrator: Orchestrator): void {
+  const run = async (args: unknown[], action: "expand" | "traverse") => {
+    const memoryId = String(args[0] ?? "");
+    const options = (args[args.length - 1] ?? {}) as Record<string, unknown>;
+    const sessionKey = typeof options.sessionKey === "string" ? options.sessionKey : "";
+    if (memoryId.length === 0 || sessionKey.length === 0) {
+      console.error("usage: navigate <expand|traverse> <memoryId> --session-key <key> [--namespace <ns>]");
+      process.exitCode = 1;
+      return;
+    }
+    let limit: number | undefined;
+    try {
+      limit = action === "traverse" ? parseLimit(options.limit) : undefined;
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+      return;
+    }
+    const service = new EngramAccessService(orchestrator);
+    try {
+      const result = await service.recallNavigate({
+        action,
+        memoryId,
+        sessionKey,
+        ...(action === "expand" && typeof options.disclosure === "string"
+          ? { disclosure: options.disclosure as "chunk" | "section" | "raw" }
+          : {}),
+        ...(action === "traverse" && typeof options.relation === "string" ? { relation: options.relation } : {}),
+        ...(limit !== undefined ? { limit } : {}),
+        ...(typeof options.namespace === "string" && options.namespace.length > 0
+          ? { namespace: options.namespace }
+          : {}),
+      });
+      if (options.json === true) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        console.log(result.rendered);
+      }
+      if (!result.ok) process.exitCode = 1;
+    } catch (err) {
+      console.error(err instanceof Error ? err.message : String(err));
+      process.exitCode = 1;
+    }
+  };
+
+  cmd
+    .command("navigate expand <memoryId>")
+    .description("Re-render a served memory at deeper disclosure (issue #1956)")
+    .option("--session-key <key>", "Session key whose recent recalls authorize the id (required)")
+    .option("--disclosure <level>", "Target depth: section or raw (default raw)")
+    .option("--namespace <ns>", "Namespace to scope the read to")
+    .option("--json", "JSON output (items + budget + disclosure spend)")
+    .action(async (...args: unknown[]) => run(args, "expand"));
+
+  cmd
+    .command("navigate traverse <memoryId>")
+    .description("Follow typed links from a served memory; neighbors as chunk summaries (issue #1956)")
+    .option("--session-key <key>", "Session key whose recent recalls authorize the id (required)")
+    .option("--relation <type>", "Optional relation filter (supports, contradicts, elaborates, ...)")
+    .option("--limit <n>", "Optional cap on returned neighbors")
+    .option("--namespace <ns>", "Namespace to scope the read to")
+    .option("--json", "JSON output (items + budget + disclosure spend)")
+    .action(async (...args: unknown[]) => run(args, "traverse"));
+}

package/src/cli.ts

@@ -14,7 +14,7 @@ import { bumpMemoryCorpusVersionForDir } from "./memory-corpus-version.js";
 import { utcDayRange } from "./transcript.js";
 import { padEndDisplay, truncateGraphemeSafe } from "./whitespace.js";
 import { runWearablesCliCommand } from "./wearables/cli.js";
-import { registerMeetingsCommands } from "./cli/meetings-commands.js"; import { registerDeepRecallCommands } from "./cli/deep-recall-commands.js";
+import { registerMeetingsCommands } from "./cli/meetings-commands.js"; import { registerDeepRecallCommands } from "./cli/deep-recall-commands.js"; import { registerRecallNavigationCommands } from "./cli/recall-navigation-commands.js";
 import { registerExportOkfCommand, registerOkfCommands } from "./cli/okf-commands.js";
 import { registerSkillsCommands } from "./cli/skills-commands.js";
 import { registerResearchStatusCommands } from "./cli/research-status-commands.js";
@@ -6230,7 +6230,7 @@ export function registerCli(
 
       registerResearchStatusCommands(cmd, orchestrator);
 
-      registerCreationLedgerCommands(cmd, orchestrator); registerMeetingsCommands(cmd, orchestrator); registerOkfCommands(cmd, orchestrator); registerDeepRecallCommands(cmd, orchestrator); registerTimelineCommands(cmd, orchestrator);
+      registerCreationLedgerCommands(cmd, orchestrator); registerMeetingsCommands(cmd, orchestrator); registerOkfCommands(cmd, orchestrator); registerDeepRecallCommands(cmd, orchestrator); registerTimelineCommands(cmd, orchestrator); registerRecallNavigationCommands(cmd, orchestrator);
 
       cmd
         .command("trust-zone-promote")

package/src/config.ts

@@ -50,6 +50,7 @@ import { parseActiveContextFields } from "./active-context-config.js";
 import { parseSkillProjectionConfig } from "./procedural/skill-projection.js";
 import { parseDriftDetectionConfig } from "./preferences/drift-config.js";
 import { parseDeepRecallConfig } from "./deep-recall-config.js";
+import { parseRecallNavigationConfig } from "./recall-navigation-config.js";
 import { parseContradictionLocalizationConfig, parseContradictionScanConfig } from "./contradiction-config.js";
 import { parseGraphPathScoringConfig } from "./graph-path-scoring-config.js";
 import { parseWritePathDedupConfig } from "./dedup/novelty-gate.js";
@@ -630,6 +631,7 @@ const MEMORY_OS_PRESETS: Record<MemoryOsPresetName, Record<string, unknown>> = {
     // memory on a conservative preset must set `procedural.enabled: true`
     // explicitly.
     procedural: { enabled: false },
+    recallNavigation: { enabled: false },
   },
   balanced: {
     maxMemoryTokens: 2000,
@@ -1820,6 +1822,8 @@ export function parseConfig(
     driftDetection: parseDriftDetectionConfig(cfg.driftDetection),
     // Budgeted deep-recall surface (issue #2332)
     deepRecall: parseDeepRecallConfig(cfg.deepRecall),
+    // Session-scoped recall navigation (issue #1956)
+    recallNavigation: parseRecallNavigationConfig(cfg.recallNavigation),
     dependencyPropagation: parseDependencyPropagationConfig(cfg),
     // Temporal Supersession (issue #375)
     temporalSupersessionEnabled: cfg.temporalSupersessionEnabled !== false, // On by default

package/src/deep-recall-config.ts

@@ -11,6 +11,7 @@
  */
 
 import { coerceBool, coerceNumber } from "./connectors/coerce.js";
+import { EngramAccessInputError } from "./access-errors.js";
 
 export interface DeepRecallConfig {
   /** Master switch for the deep-recall surface. Default false. */
@@ -113,3 +114,34 @@ export function parseDeepRecallMaxSteps(raw: unknown): number | undefined {
   }
   throw new Error(`maxSteps must be a non-negative integer; got ${JSON.stringify(raw)}`);
 }
+
+/**
+ * Resolve the effective per-invocation config from a caller-requested
+ * `maxSteps` override (§33 semantics, extracted from the access service so
+ * the god file stays under its ratchet cap):
+ * - undefined request keeps the parsed config untouched;
+ * - `deepRecall.maxSteps: 0` is a documented disable value — any positive
+ *   override is a refusal, not a ceiling comparison;
+ * - otherwise the override must not exceed the configured ceiling.
+ */
+export function resolveEffectiveDeepRecallConfig(
+  cfg: DeepRecallConfig,
+  requestedSteps: number | undefined,
+): DeepRecallConfig {
+  if (requestedSteps === undefined) return cfg;
+  if (typeof requestedSteps !== "number" || !Number.isInteger(requestedSteps) || requestedSteps < 0) {
+    throw new EngramAccessInputError("deepRecall: maxSteps must be a non-negative integer");
+  }
+  if (cfg.maxSteps <= 0) {
+    if (requestedSteps > 0) {
+      throw new EngramAccessInputError(
+        "deepRecall: the policy loop is disabled (deepRecall.maxSteps=0); maxSteps must be 0"
+      );
+    }
+  } else if (requestedSteps > cfg.maxSteps) {
+    throw new EngramAccessInputError(
+      `deepRecall: maxSteps ${requestedSteps} exceeds the configured ceiling ${cfg.maxSteps}`
+    );
+  }
+  return { ...cfg, maxSteps: requestedSteps };
+}

package/src/index.ts

@@ -1451,5 +1451,4 @@ export * from "./maintenance/atomic-file.js";
 // Privacy-safe action-to-outcome trajectory eval (issue #2345)
 export * from "./eval-trajectory.js";
 export { MemoryControllerCoordinator, chooseAction, computeEvidenceReportHash, controllerConfigHash, evaluateActiveGates, hashControllerState, verifyEvidenceReport } from "./memory-controller.js";
-export type { ActiveContextAdapter, ActiveContextMessage, ActiveContextPlan, MemoryControllerActionFamily, MemoryControllerChoice, MemoryControllerConfig, MemoryControllerDeps, MemoryControllerEvent, MemoryControllerEvidence, MemoryControllerEvidenceReport, MemoryControllerExecutors, MemoryControllerMode, MemoryControllerPairedSeedEvidence, MemoryControllerReceipt, MemoryControllerRecorder, MemoryControllerReportReader, MemoryControllerRunResult, MemoryControllerState } from "./memory-controller.js";
-export * from "./recall-navigate.js";
+export type { ActiveContextAdapter, ActiveContextMessage, ActiveContextPlan, MemoryControllerActionFamily, MemoryControllerChoice, MemoryControllerConfig, MemoryControllerDeps, MemoryControllerEvent, MemoryControllerEvidence, MemoryControllerEvidenceReport, MemoryControllerExecutors, MemoryControllerMode, MemoryControllerPairedSeedEvidence, MemoryControllerReceipt, MemoryControllerRecorder, MemoryControllerReportReader, MemoryControllerRunResult, MemoryControllerState } from "./memory-controller.js"; export * from "./recall-navigate.js"; export * from "./recall-navigation.js"; export * from "./recall-navigation-config.js";

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/mcp-read-only-tools.ts

@@ -28,6 +28,8 @@ export const MCP_READ_ONLY_TOOL_SUFFIXES: Readonly<Record<string, true>> = {
   meetings_list: true,
   meetings_get: true,
   deep_recall: true,
+  memory_expand: true,
+  memory_traverse: true,
   standup: true,
   action_confidence: true,
   capsule_list: 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 {