@remnic/core 9.69.56 → 9.69.58

package/dist/tagging-BjsNFKWz.d.ts

@@ -1,240 +0,0 @@
-import { aP as LocationSegment, aQ as LocationPlace, aR as LocationConfig, M as MemoryFile, aS as WearableConversation } from './types-Du6VdoAg.js';
-import { S as StorageManager } from './storage-CMm-3aD3.js';
-
-/**
- * Core location matcher (issue #2046) — the ONE place that decides whether a
- * memory or wearable conversation gets provider location context.
- *
- * Pure and deterministic: no IO, no clocks, no randomness. Inputs are UTC
- * ISO-8601 instants and half-open [start, end) intervals everywhere.
- *
- * Rules (issue #2046 / umbrella #2043 decision D):
- * 1. A valid memory interval is required — derived ONLY from the memory's own
- *   bi-temporal frontmatter (`valid_at` / `observedAt` / `invalid_at`), never
- *   from wall-clock time or message order. Untimed memories stay untagged.
- * 2. Intervals longer than 24h describe long-lived facts, not events at a
- *   place; they stay untagged.
- * 3. A place is tagged only when it is DOMINANT (strictly the longest overlap
- *   among candidate places; ties are conflicts and leave the memory untagged)
- *   and meets `minimumOverlapSeconds` and `minimumConfidence`.
- * 4. Only resolved named places participate (`kind` home/work/poi): transit
- *   legs and unnamed visits never tag a memory.
- * 5. No address is ever inferred from text, coordinates, IP, or proximity —
- *   only provider-supplied place metadata is echoed, and coordinates only
- *   when `retainCoordinates` is enabled.
- *
- * Provider-owned metadata contract: the tag is `location:<stable-place-slug>`
- * and the opaque provider place id lives in structured attributes. Every
- * field the matcher writes is provider-owned; a memory that carries
- * location-ish metadata WITHOUT the `locationSource` marker is treated as
- * manual/user-authored and is never touched.
- */
-
-/** Maximum memory span eligible for location tagging. */
-declare const LOCATION_MATCH_MAX_MEMORY_SPAN_MS: number;
-/** Prefix of provider-owned location tags. */
-declare const LOCATION_TAG_PREFIX = "location:";
-/** Structured-attribute keys owned by the tagging pipeline (never manual). */
-declare const LOCATION_ATTRIBUTE_KEYS: readonly ["locationSource", "locationPlaceId", "locationPlace", "locationConfidence", "locationVisitStart", "locationVisitEnd", "locationLatitude", "locationLongitude"];
-interface LocationTagPolicy {
-    minimumOverlapSeconds: number;
-    minimumConfidence: number;
-    retainCoordinates: boolean;
-}
-/** The memory side of a match: a half-open interval, or a single instant. */
-type MemoryLocationWindow = {
-    kind: "interval";
-    startUtc: string;
-    endUtc: string;
-} | {
-    kind: "instant";
-    atUtc: string;
-};
-/** Why a window was rejected before matching. */
-type WindowRejectReason = "untimed" | "span-too-long";
-interface WindowResult {
-    window?: MemoryLocationWindow;
-    /** Local days (YYYY-MM-DD in the tag policy timezone) the window touches. */
-    days?: string[];
-    rejected?: WindowRejectReason;
-}
-/**
- * Derive the match window from a memory's own frontmatter. `validAt` (the
- * event start; assumed copies carry the ingestion anchor) opens the window;
- * `invalid_at` closes it. An end-only memory (no start bound) is untimed.
- */
-declare function memoryLocationWindow(frontmatter: {
-    valid_at?: string;
-    observedAt?: string;
-    invalid_at?: string;
-}, localDay: (instantUtc: string) => string): WindowResult;
-/** One source's segments for a day, keyed by the configured source id. */
-interface LocationSourceSegments {
-    sourceId: string;
-    segments: LocationSegment[];
-}
-interface LocationMatch {
-    sourceId: string;
-    place: LocationPlace;
-    /** Overlap (ms) with the window — interval mode; see `visitMs` otherwise. */
-    overlapMs: number;
-    /** Total dwell (ms) of the dominant place inside the window's day(s). */
-    visitMs: number;
-    /** Minimum contributing segment confidence, when any source reported one. */
-    confidence?: number;
-    /** Envelope [start, end) of the segments that produced the match. */
-    visitStartUtc: string;
-    visitEndUtc: string;
-}
-type MatchOutcome = {
-    status: "matched";
-    match: LocationMatch;
-} | {
-    status: "unmatched";
-    reason: "no-overlap" | "ambiguous" | "below-minimum-overlap" | "below-minimum-confidence";
-};
-/**
- * The dominant qualifying place for a window, across every source's
- * segments. Deterministic: strict overlap comparison, ties (conflicts) are
- * rejected, and equal-place contributions merge across sources.
- */
-declare function matchDominantPlace(window: MemoryLocationWindow, sources: readonly LocationSourceSegments[], policy: LocationTagPolicy): MatchOutcome;
-/** Deterministic tag slug for a provider place id (`reitti:place:7` → `reitti-place-7`). */
-declare function locationTagSlug(placeId: string): string;
-/** The provider-owned tag for a matched place. */
-declare function locationTagForPlace(placeId: string): string;
-/** Provider-owned structured attributes describing a match. */
-declare function locationAttributesForMatch(match: LocationMatch, policy: LocationTagPolicy): Record<string, string>;
-interface LocationUpdatePlan {
-    /** Patch for `writeMemoryFrontmatter`; absent when nothing changes. */
-    patch?: {
-        tags: string[];
-        structuredAttributes: Record<string, string>;
-    };
-    /** Outcome for reporting. */
-    outcome: "tagged" | "updated" | "removed" | "unchanged" | "manual-metadata" | "unmatched" | "untimed" | "span-too-long";
-}
-/**
- * Plan the provider-owned update for one memory: a match adds/replaces ONLY
- * provider-owned fields; a lost match removes them (corrected observations);
- * manual location metadata (no `locationSource` marker) always wins and is
- * never touched. Unrelated tags and attributes survive every path.
- */
-declare function planLocationUpdate(frontmatter: {
-    tags?: string[];
-    structuredAttributes?: Record<string, string>;
-}, outcome: MatchOutcome, policy: LocationTagPolicy): LocationUpdatePlan;
-
-/**
- * Location tagging service (issue #2046) — the IO half around the pure
- * matcher in `matching.ts`. Three consumers share it so the policy can never
- * fork:
- *
- *  1. Write-time enrichment: after an extraction batch has cleared the
- *     trust/importance/content-hash gates and persisted, the caller tags the
- *     new memories (post-write, best-effort, never fails the extraction).
- *  2. Historical backfill (`location/backfill.ts`): the same plan/apply core
- *     over a bounded date range, idempotent by construction.
- *  3. Wearable conversation fill: `WearableConversation.location` is filled
- *     ONLY when the source did not provide one and the match passes policy.
- *
- * Segment data comes from the machine-global location sync state
- * (`state/locations/sync.json`, ≤ 90 tracked days — matching the bounded
- * backfill range). Reads are plain file loads; every memory mutation goes
- * through `StorageManager.writeMemoryFrontmatter`, the atomic frontmatter
- * chokepoint that preserves content (and therefore the content hash),
- * lifecycle, and versioning invariants.
- */
-
-/** Segments for one local day, per source id, from the sync state. */
-type DaySegmentIndex = Map<string, LocationSourceSegments[]>;
-/** Load every tracked day's per-source segments (one file read). */
-declare function loadDaySegmentIndex(memoryDir: string): Promise<DaySegmentIndex>;
-declare function locationTagPolicy(config: LocationConfig): LocationTagPolicy;
-/** Every tagging path is off unless BOTH gates are on. */
-declare function locationTaggingEnabled(config: LocationConfig): boolean;
-/**
- * Write-time post-persist hook (issue #2046): tag the memories an extraction
- * batch just made durable. Best-effort by contract — gated on both location
- * gates, and a location failure must never fail the extraction that already
- * persisted.
- */
-declare function tagPersistedMemories(storage: StorageManager, memoryIds: string[], config: {
-    memoryDir: string;
-    location?: LocationConfig;
-}): Promise<void>;
-interface LocationEnrichmentCounts {
-    tagged: number;
-    updated: number;
-    removed: number;
-    unchanged: number;
-    unmatched: number;
-    manual: number;
-    untimed: number;
-    spanTooLong: number;
-    failed: number;
-}
-declare function emptyEnrichmentCounts(): LocationEnrichmentCounts;
-interface EnrichMemoriesOptions {
-    storage: Pick<StorageManager, "getMemoryById" | "writeMemoryFrontmatter">;
-    memoryDir: string;
-    config: LocationConfig;
-    /** Enrich exactly these memory ids (write-time path). */
-    memoryIds?: string[];
-    /** Pre-loaded memories (backfill path — one readAllMemories per run). */
-    memories?: MemoryFile[];
-    /** Reuse a caller-loaded segment index (backfill). */
-    index?: DaySegmentIndex;
-    /** Skip every mutation and only report (dry-run). */
-    dryRun?: boolean;
-}
-/**
- * Apply the matcher to a set of memories and patch provider-owned location
- * metadata. A failure on ONE memory is counted and skipped — it never blocks
- * the others (failure isolation, issue #2046).
- */
-declare function enrichMemoriesWithLocation(options: EnrichMemoriesOptions): Promise<LocationEnrichmentCounts>;
-/**
- * Fill `WearableConversation.location` for conversations whose source did not
- * provide one. Missing-only and source-aware: a provider-supplied value is
- * never overwritten, and a failing conversation never blocks the others.
- */
-declare function fillWearableConversationLocations(conversations: WearableConversation[], deps: {
-    memoryDir: string;
-    config: LocationConfig;
-}): Promise<void>;
-/** Render an opt-in, labels-only location context section for a day summary. */
-declare function renderDayLocationContext(memoryDir: string, date: string, config: LocationConfig): Promise<string | null>;
-/**
- * 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.
- */
-declare function briefingLocationSection(memoryDir: string, windowStartUtc: string, config: LocationConfig): Promise<string | null>;
-declare function applyBriefingLocationContext<T extends {
-    markdown: string;
-    json: Record<string, unknown>;
-}>(result: T, includeLocation: boolean | undefined, memoryDir: string, windowStartUtc: string, location: LocationConfig): Promise<T>;
-/**
- * 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.
- */
-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.
- */
-declare function daySummaryAutoOptions(request: LocationContextRequestOptions & {
-    timeZone?: string;
-}): {
-    timeZone?: string;
-    includeLocation: boolean;
-};
-
-export { tagPersistedMemories as A, type DaySegmentIndex as D, type EnrichMemoriesOptions as E, type LocationEnrichmentCounts as L, type MatchOutcome as M, type WindowRejectReason as W, applyBriefingLocationContext as a, LOCATION_ATTRIBUTE_KEYS as b, LOCATION_MATCH_MAX_MEMORY_SPAN_MS as c, LOCATION_TAG_PREFIX as d, type LocationContextRequestOptions as e, type LocationMatch as f, type LocationSourceSegments as g, type LocationTagPolicy as h, type LocationUpdatePlan as i, type MemoryLocationWindow as j, type WindowResult as k, briefingLocationSection as l, daySummaryAutoOptions as m, emptyEnrichmentCounts as n, enrichMemoriesWithLocation as o, fillWearableConversationLocations as p, loadDaySegmentIndex as q, locationAttributesForMatch as r, locationTagForPlace as s, locationTagPolicy as t, locationTagSlug as u, locationTaggingEnabled as v, matchDominantPlace as w, memoryLocationWindow as x, planLocationUpdate as y, renderDayLocationContext as z };

package/dist/types-B1VHaf2w.d.ts

@@ -1,126 +0,0 @@
-/**
- * Peer registry types — issue #679 PR 1/5.
- *
- * Generalizes the singular identity-anchor model to a multi-peer registry.
- * Every party Remnic interacts with — humans, agents, integrations, and
- * "self" — is represented as a `Peer` with an evolving cognitive profile.
- *
- * This module defines pure types only. Storage primitives live in
- * `./storage.ts`. Reasoner integration, recall injection, CLI/HTTP/MCP
- * surfaces, and migration of existing identity-anchor data ship in later
- * PRs (2/5 — 5/5).
- */
-/**
- * Kind of peer.
- *
- * - `self`     — the current Remnic operator (replaces singular identity-anchor).
- * - `human`    — another human collaborator distinct from self.
- * - `agent`    — another AI agent (Claude Code, Codex, Hermes, etc.).
- * - `integration` — non-conversational integration (cron, webhook, importer).
- */
-type PeerKind = "self" | "human" | "agent" | "integration";
-/**
- * Stable, slow-changing facts about a peer.
- *
- * `id` matches `^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$`, 1-64 chars,
- * with no leading/trailing/consecutive dots or dashes. Stored on disk under
- * `peers/{id}/identity.md` as YAML frontmatter + markdown body.
- */
-interface Peer {
-    /** Stable, opaque identifier. See PEER_ID_PATTERN. */
-    readonly id: string;
-    /** Kind of peer. Drives default profile schema and recall posture. */
-    readonly kind: PeerKind;
-    /** Human-readable display name. Distinct from `id`; mutable. */
-    readonly displayName: string;
-    /** ISO-8601 timestamp of first registration. */
-    readonly createdAt: string;
-    /** ISO-8601 timestamp of most recent update to identity. */
-    readonly updatedAt: string;
-    /** Optional free-form markdown body for the identity kernel. */
-    readonly notes?: string;
-}
-/**
- * Evolving cognitive profile for a peer.
- *
- * Updated by the async profile reasoner (PR 2/5) from observable session
- * signals. Every field carries provenance back to its originating session
- * and signal. This PR only defines the shape — population is deferred.
- */
-interface PeerProfile {
-    /** Peer this profile belongs to. */
-    readonly peerId: string;
-    /** ISO-8601 timestamp of most recent profile mutation. */
-    readonly updatedAt: string;
-    /**
-     * Arbitrary key/value profile fields. Values are markdown strings.
-     * Keys are stable section identifiers (e.g. `communication_style`,
-     * `recurring_concerns`). The reasoner is responsible for choosing
-     * keys; this PR does not constrain them beyond requiring strings.
-     */
-    readonly fields: Record<string, string>;
-    /**
-     * Per-field provenance. Maps field key → list of provenance entries.
-     * A field may have multiple sources (the reasoner accumulates evidence
-     * across sessions before promoting a field).
-     */
-    readonly provenance: Record<string, ReadonlyArray<PeerProfileFieldProvenance>>;
-}
-/**
- * Provenance for a single profile-field mutation.
- *
- * Reasoner output (PR 2/5) attaches one of these every time it touches a
- * field, so the user can audit exactly why a profile claim exists.
- */
-interface PeerProfileFieldProvenance {
-    /** ISO-8601 timestamp the field was set/updated by this signal. */
-    readonly observedAt: string;
-    /** Originating session id (or other source identifier). */
-    readonly sourceSessionId?: string;
-    /** Short label for the signal type (e.g. "explicit_preference"). */
-    readonly signal: string;
-    /** Optional free-form note explaining the inference. */
-    readonly note?: string;
-}
-/**
- * One row of the append-only interaction log for a peer.
- *
- * Stored on disk under `peers/{id}/interactions.log.md` as a sequence of
- * markdown bullet entries with a leading ISO-8601 timestamp. Append-only
- * by contract — the reasoner reads this log to derive profile updates.
- */
-interface PeerInteractionLogEntry {
-    /** ISO-8601 timestamp the interaction occurred. */
-    readonly timestamp: string;
-    /** Originating session id, if any. */
-    readonly sessionId?: string;
-    /** Short kind label (e.g. "message", "tool_call", "preference_set"). */
-    readonly kind: string;
-    /** Free-form markdown summary of the interaction. */
-    readonly summary: string;
-}
-/**
- * Regex enforced on `Peer.id`. Exported so callers can mirror validation
- * before constructing a `Peer`.
- *
- * Rules:
- *   - 1-64 characters total
- *   - First and last character must be `[A-Za-z0-9]`
- *   - Interior may contain `.`, `_`, `-` in addition to alphanumerics
- *   - No leading or trailing dot/dash/underscore
- *   - No consecutive separators (`..`, `--`, `__`, `.-`, etc.)
- *
- * Cursor Medium: previously the regex allowed `a..b` even though the
- * docs claimed otherwise — a separate JS-side check enforced the rule
- * but the standalone PATTERN was wrong for any external consumer
- * relying on it. Tighten the regex itself so PEER_ID_PATTERN is the
- * single source of truth: an alphanumeric, optionally followed by
- * groups of (one separator + one-or-more alphanumerics), with the
- * final group ending on an alphanumeric. Negative lookahead-free so
- * it works in any JS engine.
- */
-declare const PEER_ID_PATTERN: RegExp;
-/** Maximum length for `Peer.id`. */
-declare const PEER_ID_MAX_LENGTH = 64;
-
-export { type PeerInteractionLogEntry as P, type Peer as a, type PeerProfile as b, PEER_ID_MAX_LENGTH as c, PEER_ID_PATTERN as d, type PeerKind as e, type PeerProfileFieldProvenance as f };

package/dist/types-DJhqDJUV.d.ts

@@ -1,50 +0,0 @@
-/**
- * Taxonomy types for the MECE knowledge directory.
- *
- * A taxonomy defines a set of categories that partition the knowledge
- * space so that every memory maps to exactly one category (Mutually
- * Exclusive, Collectively Exhaustive).
- */
-/**
- * A single category in the taxonomy.
- *
- * @property id          - Slug: lowercase letters, digits, hyphens; max 32 chars.
- * @property name        - Human-readable display name.
- * @property description - What belongs in this category.
- * @property filingRules - Prose rules used by the resolver decision tree.
- * @property parentId    - Optional parent category for nesting.
- * @property priority    - Tie-breaker: lower number wins when a memory
- *                         could belong to multiple categories.
- * @property memoryCategories - Which MemoryCategory values map here.
- */
-interface TaxonomyCategory {
-    id: string;
-    name: string;
-    description: string;
-    filingRules: string[];
-    parentId?: string;
-    priority: number;
-    memoryCategories: string[];
-}
-/**
- * A versioned taxonomy comprising an ordered list of categories.
- */
-interface Taxonomy {
-    version: number;
-    categories: TaxonomyCategory[];
-}
-/**
- * The output of the resolver: which category a piece of knowledge
- * belongs to, with confidence and alternatives.
- */
-interface ResolverDecision {
-    categoryId: string;
-    confidence: number;
-    reason: string;
-    alternatives: Array<{
-        categoryId: string;
-        reason: string;
-    }>;
-}
-
-export type { ResolverDecision as R, Taxonomy as T, TaxonomyCategory as a };