@remnic/core 9.64.4 → 9.65.1

package/dist/lcm/index.js

@@ -5,7 +5,11 @@ import {
 import {
   LcmEngine,
   extractLcmConfig
-} from "../chunk-5HERQ5FX.js";
+} from "../chunk-256FBCVX.js";
+import {
+  ensureLcmStateDir,
+  openLcmDatabase
+} from "../chunk-DDA47TES.js";
 import {
   LcmSummarizer
 } from "../chunk-ZPUIRTIZ.js";
@@ -21,10 +25,6 @@ import {
   assembleCompressedHistory,
   assembleCompressedHistoryWithTrace
 } from "../chunk-UXPUUL3G.js";
-import {
-  ensureLcmStateDir,
-  openLcmDatabase
-} from "../chunk-DDA47TES.js";
 import "../chunk-4RA3C3EV.js";
 import "../chunk-AQEJKOKI.js";
 import {

package/dist/lcm/tools.d.ts

@@ -7,8 +7,9 @@ import './summarizer.js';
 import './dag.js';
 import './recall.js';
 import './queue.js';
-import '../types-BP5MC8UU.js';
+import '../types-BrEzuxPA.js';
 import '../bounded-jsonl-state.js';
+import '../types-CM86alG1.js';
 import '../operator-doctor-types.js';
 import '../external-wiki-config.js';
 import '../contradiction-config.js';

package/dist/lifecycle.d.ts

@@ -1,6 +1,7 @@
-import { V as LifecycleState, x as MemoryCategory, M as MemoryFile, m as MemoryFrontmatter } from './types-BP5MC8UU.js';
+import { V as LifecycleState, x as MemoryCategory, M as MemoryFile, m as MemoryFrontmatter } from './types-BrEzuxPA.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
+import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/live-connectors-runner.d.ts

@@ -1,7 +1,8 @@
 import { L as LiveConnector, C as ConnectorConfig, a as ConnectorDocument } from './framework-CNDn2164.js';
-import { L as LiveConnectorsConfig } from './types-BP5MC8UU.js';
+import { L as LiveConnectorsConfig } from './types-BrEzuxPA.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
+import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/local-llm.d.ts

@@ -1,7 +1,8 @@
-import { P as PluginConfig } from './types-BP5MC8UU.js';
+import { P as PluginConfig } from './types-BrEzuxPA.js';
 import { ModelRegistry } from './model-registry.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
+import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/local-llm.js

@@ -1,8 +1,8 @@
 import {
   LocalLlmClient
-} from "./chunk-MB6GLPRY.js";
-import "./chunk-JUXOTY6J.js";
+} from "./chunk-IVKIODHO.js";
 import "./chunk-WKDFJXW5.js";
+import "./chunk-JUXOTY6J.js";
 import "./chunk-TOTT6S2V.js";
 import "./chunk-JUOZ62Y7.js";
 import "./chunk-O75CRYGF.js";

package/dist/local-model-endpoint.d.ts

@@ -1,6 +1,7 @@
-import { P as PluginConfig } from './types-BP5MC8UU.js';
+import { P as PluginConfig } from './types-BrEzuxPA.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
+import './types-CM86alG1.js';
 import './operator-doctor-types.js';
 import './external-wiki-config.js';
 import './contradiction-config.js';

package/dist/location/index.d.ts

@@ -0,0 +1,295 @@
+import { L as LocationProvider, a as LocationConfig, b as LocationPlace, c as LocationObservation, d as LocationSegment } from '../types-CM86alG1.js';
+export { e as LocationObservationPage, f as LocationProviderCheck, g as LocationSourceConfig } from '../types-CM86alG1.js';
+
+/**
+ * Location provider registry (issue #2044).
+ *
+ * In-memory only: host adapters register provider implementations at startup.
+ * Core never statically imports an optional provider package — the registry
+ * holds whatever the host wired in, and a configured source whose provider is
+ * not registered is skipped (not an error), so partial installs keep working.
+ */
+
+declare function registerLocationProvider(provider: LocationProvider): void;
+declare function getLocationProvider(id: string): LocationProvider | undefined;
+declare function listLocationProviders(): string[];
+/** Test-only: reset the registry between cases. */
+declare function clearLocationProviders(): void;
+
+/** The inert default: disabled, UTC days, one day per run, no sources, no coordinates. */
+declare function defaultLocationConfig(): LocationConfig;
+/**
+ * Parse the unified `location.*` block. `enabled` gates everything and
+ * requires at least one source; a source's own `enabled` gates that source
+ * only. `retainCoordinates` defaults to `false` — coordinates are privacy
+ * data and are dropped everywhere unless explicitly retained.
+ */
+declare function parseLocationConfig(raw: unknown): LocationConfig;
+
+/**
+ * Location interval math (issue #2044).
+ *
+ * Pure, deterministic helpers over UTC ISO-8601 instants: half-open
+ * [start, end) day windows (reusing the DST-correct activity day-window), IANA
+ * local-day bucketing, overlap, observation→segment dwell, and dominant-place
+ * selection with stable tie-breaking. No IO, no clocks, no randomness.
+ */
+
+declare function isValidLocationDate(date: string): boolean;
+/** Half-open [start, end) UTC ISO bounds of a local day. */
+declare function locationDayWindow(date: string, timezone: string): {
+    startUtc: string;
+    endUtc: string;
+};
+/** The IANA local calendar day (YYYY-MM-DD) an instant falls in. */
+declare function localDayKey(instantUtc: string, timezone: string): string;
+/** Bucket observations into their IANA local days, sorted within each day. */
+declare function bucketObservationsByDay(observations: readonly LocationObservation[], timezone: string): Map<string, LocationObservation[]>;
+/** Overlap in ms of two half-open intervals; 0 when disjoint. */
+declare function intervalOverlapMs(a: {
+    startUtc: string;
+    endUtc: string;
+}, b: {
+    startUtc: string;
+    endUtc: string;
+}): number;
+/**
+ * Derive place-visit segments from a day's observations: each observation
+ * covers [its instant, the next observation's instant ∩ window end). The last
+ * observation is capped by the window end, so dwell never crosses the day
+ * boundary. Out-of-window observations are a provider contract violation and
+ * are rejected loudly rather than silently reshaping the day. Coordinates are
+ * stripped unless `retainCoordinates` is set.
+ */
+declare function observationSegments(observations: readonly LocationObservation[], window: {
+    startUtc: string;
+    endUtc: string;
+}, options: {
+    retainCoordinates: boolean;
+}): LocationSegment[];
+/** Total time a place was occupied (union of its segment intervals, ms). */
+interface PlaceDuration {
+    place: LocationPlace;
+    totalMs: number;
+    /** Earliest segment start contributing to this place's total. */
+    firstStartUtc: string;
+}
+/** Per-place totals across every segment given (multi-source safe). */
+declare function placeDurations(segments: readonly LocationSegment[]): PlaceDuration[];
+interface DominantPlaceResult {
+    place: LocationPlace;
+    totalMs: number;
+}
+/**
+ * The place with the longest total occupancy. Ties are stable and
+ * deterministic: earlier first start wins, then the lexicographically smaller
+ * place id — never insertion order.
+ */
+declare function dominantPlace(segments: readonly LocationSegment[]): DominantPlaceResult | null;
+
+/**
+ * Location day-file + sync-state store (issue #2044).
+ *
+ * Day documents live at `<memoryDir>/locations/<YYYY-MM-DD>.md` — OUTSIDE the
+ * memory scan roots (facts/, entities/, …) so raw location history never
+ * surfaces as a memory in recall or governance passes, and INSIDE the QMD
+ * collection root so the markdown stays full-text searchable once an index
+ * update runs. Per-source sync state lives at
+ * `<memoryDir>/state/locations/sync.json` and is written only after the day
+ * document is durable (see pipeline.ts).
+ *
+ * Both writes are atomic (temp file + rename) and containment-checked: a
+ * symlinked `locations/` root or day file is rejected even when it resolves
+ * inside the memory dir (AGENTS.md pattern #3), and a path that escapes the
+ * memory dir is refused outright.
+ */
+
+declare const LOCATIONS_DIR_NAME = "locations";
+declare const LOCATION_DAY_KIND = "location-day";
+declare const LOCATION_DAY_FORMAT_VERSION = 1;
+declare function locationDayFilePath(memoryDir: string, date: string): string;
+declare function locationSyncStateFilePath(memoryDir: string): string;
+/** A source's derived day payload, kept in sync state for multi-source merges. */
+interface LocationSourceDayPayload {
+    observationCount: number;
+    segments: LocationSegment[];
+    providerDisplayName?: string;
+}
+interface LocationSourceSyncState {
+    lastSyncedAtUtc?: string;
+    days?: Record<string, LocationSourceDayPayload>;
+}
+interface LocationSyncStateFile {
+    version: 1;
+    sources: Record<string, LocationSourceSyncState>;
+}
+declare function emptyLocationSyncState(): LocationSyncStateFile;
+declare function loadLocationSyncState(memoryDir: string): Promise<LocationSyncStateFile>;
+declare function saveLocationSyncState(memoryDir: string, state: LocationSyncStateFile): Promise<void>;
+/**
+ * Record one source's completed day sync. Runs the whole read-modify-write
+ * under the per-directory state lock so concurrent sources cannot clobber
+ * each other, and prunes day payloads beyond the retention cap.
+ */
+declare function updateLocationSourceDay(memoryDir: string, sourceId: string, date: string, payload: LocationSourceDayPayload, completedAtUtc: string): Promise<LocationSyncStateFile>;
+/** Frontmatter persisted on a rendered day document. */
+interface LocationDayMeta {
+    kind: typeof LOCATION_DAY_KIND;
+    date: string;
+    timezone: string;
+    formatVersion: number;
+    sources: string[];
+    observationCount: number;
+    /** SHA-256 of the rendered body (rebuild idempotency). */
+    contentHash: string;
+}
+/** A parsed day document (frontmatter + rendered body). */
+interface LocationDayDocument {
+    meta: LocationDayMeta;
+    body: string;
+}
+/** The per-source view a day document is composed from. */
+interface LocationDaySourceEntry extends LocationSourceDayPayload {
+    /** Provider display name for the timeline heading; falls back to the id. */
+    providerDisplayName?: string;
+}
+declare function hashLocationBody(body: string): string;
+declare function composeLocationDayBody(date: string, timezone: string, sources: Record<string, LocationDaySourceEntry>): string;
+declare function composeLocationDayMeta(date: string, timezone: string, sources: Record<string, LocationDaySourceEntry>, body: string): LocationDayMeta;
+declare function serializeLocationDay(meta: LocationDayMeta, body: string): string;
+/** A day document's frontmatter, parsed for idempotency checks and status. */
+interface LocationDaySummary {
+    date: string;
+    timezone: string;
+    sources: string[];
+    observationCount: number;
+    contentHash: string;
+}
+/**
+ * Parse a day document's frontmatter. Returns null when the content is not a
+ * location day document (wrong kind, missing frontmatter) so callers can
+ * distinguish a foreign file from a corrupt one.
+ */
+declare function parseLocationDaySummary(raw: string): LocationDaySummary | null;
+/**
+ * Idempotently persist a day document: skip the write when the on-disk
+ * contentHash already matches. The write is atomic and containment-checked;
+ * the caller (pipeline) advances sync state only after this resolves.
+ */
+declare function writeLocationDay(memoryDir: string, date: string, serialized: string): Promise<boolean>;
+/** Read a stored day document's raw markdown; null when absent. */
+declare function readLocationDay(memoryDir: string, date: string): Promise<string | null>;
+/** List dates that have a stored day document, newest first. */
+declare function listLocationDayDates(memoryDir: string): Promise<string[]>;
+
+/**
+ * Location day-sync pipeline (issue #2044).
+ *
+ * For one local day, each configured (enabled, registered) provider's
+ * observations are fetched over the day's half-open UTC window, folded into
+ * place-visit segments, merged with the other sources' last-known day
+ * payloads from sync state, and rendered to the day document. Sync state
+ * advances only AFTER the day document (when any) is durable, so a failed
+ * write never moves the watermark past data that did not land. An empty
+ * fetch is a successful sync — never conflated with a provider failure
+ * (AGENTS.md rule 22).
+ */
+
+interface LocationDaySyncOptions {
+    config: LocationConfig;
+    memoryDir: string;
+    date: string;
+    signal?: AbortSignal;
+    /** Runaway-pagination guard; defaults to MAX_SYNC_PAGES. */
+    maxPages?: number;
+    now?: () => Date;
+    /** Provider lookup seam (defaults to the registry); tests inject doubles. */
+    getProvider?: (id: string) => LocationProvider | undefined;
+}
+interface LocationSourceSyncResult {
+    sourceId: string;
+    status: "synced" | "skipped" | "failed";
+    skipReason?: "source-disabled" | "provider-not-registered";
+    fetched: number;
+    dayWritten: boolean;
+    stateSaved: boolean;
+    /** Sanitized provider error (no tokens, URLs, or coordinates). */
+    error?: string;
+}
+/** Redact credential, URL query, and coordinate shapes from a provider error. */
+declare function sanitizeProviderError(error: unknown): string;
+/**
+ * Sync every configured source for one local day. The master gate
+ * (`config.enabled === false`) short-circuits every path: no providers are
+ * contacted and nothing touches the filesystem. A provider failure fails
+ * that source only (state not advanced) and never blocks the others.
+ */
+declare function syncLocationDay(options: LocationDaySyncOptions): Promise<LocationSourceSyncResult[]>;
+
+/**
+ * Location surface helpers (issue #2044): status, provider health checks, and
+ * multi-day sync. Pure `@remnic/core` — no optional packages, no host CLI
+ * wiring; a host adapter (or the core CLI, in a later slice) renders these
+ * structured results into its own command surface.
+ */
+
+interface LocationSourceStatus {
+    id: string;
+    enabled: boolean;
+    providerRegistered: boolean;
+    lastSyncedAtUtc?: string;
+    trackedDays: number;
+}
+interface LocationDayStatus {
+    date: string;
+    sources: string[];
+    observationCount: number;
+}
+interface LocationStatusReport {
+    enabled: boolean;
+    timezone: string;
+    sources: LocationSourceStatus[];
+    /** Stored day documents, newest first (at most `maxDays`). */
+    recentDays: LocationDayStatus[];
+}
+interface LocationStatusOptions {
+    /** Provider lookup seam (defaults to the registry); tests inject doubles. */
+    getProvider?: (id: string) => LocationProvider | undefined;
+    /** Cap on day documents listed; defaults to 7. */
+    maxDays?: number;
+    now?: () => Date;
+}
+declare function locationStatus(config: LocationConfig, memoryDir: string, options?: LocationStatusOptions): Promise<LocationStatusReport>;
+interface LocationSourceCheckResult {
+    id: string;
+    ok: boolean;
+    detail?: string;
+    skipped?: "location-disabled" | "source-disabled" | "provider-not-registered";
+}
+interface LocationCheckOptions {
+    signal?: AbortSignal;
+    getProvider?: (id: string) => LocationProvider | undefined;
+}
+/** Probe every configured provider's health. The master gate short-circuits. */
+declare function checkLocationSources(config: LocationConfig, options?: LocationCheckOptions): Promise<LocationSourceCheckResult[]>;
+interface LocationSyncRunOptions extends Omit<LocationDaySyncOptions, "config" | "date" | "memoryDir"> {
+    config: LocationConfig;
+    memoryDir: string;
+    /** Exclusive end date (local YYYY-MM-DD); defaults to today in config.timezone. */
+    endDate?: string;
+    /** Number of days to sync ending at endDate; defaults to config.syncDays. */
+    days?: number;
+    now?: () => Date;
+}
+/**
+ * Sync the trailing `days` local days ending AT `endDate` (inclusive).
+ * `endDate` defaults to yesterday in config.timezone (today is incomplete);
+ * days run oldest-first so a failure stops before newer days, matching the
+ * incremental-sync intent of `syncDays`.
+ */
+declare function syncLocation(options: LocationSyncRunOptions): Promise<Array<{
+    date: string;
+    results: LocationSourceSyncResult[];
+}>>;
+
+export { type DominantPlaceResult, LOCATIONS_DIR_NAME, LOCATION_DAY_FORMAT_VERSION, LOCATION_DAY_KIND, type LocationCheckOptions, LocationConfig, type LocationDayDocument, type LocationDayMeta, type LocationDaySourceEntry, type LocationDayStatus, type LocationDaySummary, type LocationDaySyncOptions, LocationObservation, LocationPlace, LocationProvider, LocationSegment, type LocationSourceCheckResult, type LocationSourceDayPayload, type LocationSourceStatus, type LocationSourceSyncResult, type LocationSourceSyncState, type LocationStatusOptions, type LocationStatusReport, type LocationSyncRunOptions, type LocationSyncStateFile, type PlaceDuration, bucketObservationsByDay, checkLocationSources, clearLocationProviders, composeLocationDayBody, composeLocationDayMeta, defaultLocationConfig, dominantPlace, emptyLocationSyncState, getLocationProvider, hashLocationBody, intervalOverlapMs, isValidLocationDate, listLocationDayDates, listLocationProviders, loadLocationSyncState, localDayKey, locationDayFilePath, locationDayWindow, locationStatus, locationSyncStateFilePath, observationSegments, parseLocationConfig, parseLocationDaySummary, placeDurations, readLocationDay, registerLocationProvider, sanitizeProviderError, saveLocationSyncState, serializeLocationDay, syncLocation, syncLocationDay, updateLocationSourceDay, writeLocationDay };