@remnic/core 9.69.55 → 9.69.57

package/dist/meetings/build.d.ts

@@ -0,0 +1,137 @@
+/**
+ * Meeting building orchestration (issue #1900, Phase 4 slice 2).
+ *
+ * Ties the pure pieces together: detect the day's meetings, fuse each window's
+ * transcript + screen context, and compose idempotent records. Day data is
+ * supplied through an injected source so fixtures (and the later activity/
+ * wearables wiring) share one code path — no hidden IO here.
+ *
+ * Gated on `meetings.enabled`: a disabled subsystem builds nothing on every
+ * surface (degradation-matrix row). Degrades within an enabled build too — a
+ * window with no audio yields an empty transcript, and no activity yields a
+ * record with no screen-context section — because `fuseMeeting` handles both.
+ */
+import { type MeetingFusionOptions } from "./fuse.js";
+import { type MeetingRecordStore } from "./store.js";
+import type { MeetingEpisodeGenResult, MeetingMemoryGenerator, MeetingsDayFactGenResult } from "./memory-generator.js";
+import type { ActivitySnapshot } from "../activity/types.js";
+import type { FusionConversationInput } from "../wearables/fusion/types.js";
+import type { DetectedMeeting, MeetingRecord, MeetingsConfig, MeetingsDetectionInput } from "./types.js";
+/** All of a day's already-loaded signals a build needs. */
+export interface MeetingDayData {
+    /** App spans + audio windows for the day (fed to the detector). */
+    detection: MeetingsDetectionInput;
+    /** Fusion conversation inputs across all wearable sources for the day. */
+    conversations: FusionConversationInput[];
+    /** Screen-activity snapshots for the day. */
+    activity?: ActivitySnapshot[];
+}
+/** Supplies a day's signals. Backed by fixtures in tests; by the activity +
+ *  wearables stores in the wiring slice. */
+export interface MeetingsDaySource {
+    loadDayData(date: string): Promise<MeetingDayData> | MeetingDayData;
+}
+export declare function buildMeetingRecordsForDay(data: MeetingDayData, config: MeetingsConfig, options?: MeetingFusionOptions, 
+/** Map a detected meeting to the id its record should carry. Defaults to the
+ *  detector's start-anchored id; the builder overrides this to preserve an
+ *  existing overlapping record's id across shifted-start resyncs. */
+resolveMeetingId?: (meeting: DetectedMeeting) => string): MeetingRecord[];
+/** Per-meeting outcome of a day build. */
+export interface MeetingBuildOutcome {
+    id: string;
+    startUtc: string;
+    endUtc: string;
+    detectionSource: string;
+    sources: string[];
+    attendees: string[];
+    snapshotCount: number;
+    /** False when the record's contentHash was unchanged (nothing rewritten). */
+    written: boolean;
+}
+/** Result of building one day's meetings. */
+export interface MeetingsDayBuildSummary {
+    date: string;
+    /** False when `meetings.enabled` is off (zero behavior). */
+    enabled: boolean;
+    meetings: MeetingBuildOutcome[];
+    /** Records written (new or changed). */
+    built: number;
+    /** Records skipped (unchanged contentHash). */
+    skipped: number;
+    /** Ids of stale same-day records deleted because they no longer detect. */
+    removed: string[];
+    /**
+     * Set when the optional reindex hook rejected AFTER records were already
+     * persisted. The store mutation still succeeded — the build is reported as
+     * successful with this generic warning, and the next scheduled index catches
+     * up. Deliberately does NOT embed the raw error text: this string is printed
+     * to the CLI's stdout, and internal error detail is logged separately.
+     */
+    reindexWarning?: string;
+    /**
+     * Set when the injected `memoryGenerator` rejected AFTER records were already
+     * persisted, OR when a successful generation returned non-fatal warnings. Like
+     * `reindexWarning`, the record writes still succeeded, so the build is reported
+     * successful with this warning; on rejection the next build (or scheduled
+     * maintenance) regenerates the missing memories. Carries no raw exception text —
+     * only the generic rejection message or the generator's own warning strings.
+     */
+    memoryWarning?: string;
+    /**
+     * Deterministic episode-memory counts, present only when a `memoryGenerator`
+     * was injected. One recall-anchor episode is written per built record (idempotent).
+     */
+    episodes?: MeetingEpisodeGenResult;
+    /**
+     * Trust-gated summary/fact counts (decisions, commitments, questions, and the
+     * synthesized summary), present only when a `memoryGenerator` with summary deps
+     * ran and `summaryMode !== "off"`. Aggregated across the day's records.
+     */
+    facts?: MeetingsDayFactGenResult;
+}
+/** Optional side effects the builder fires after a day build. */
+export interface MeetingsBuilderHooks {
+    /**
+     * Invoked once per build when records changed (`built > 0 || removed > 0`).
+     * Meeting records live inside the QMD collection root for full-text search,
+     * so a host that wants them discoverable immediately (rather than at the next
+     * scheduled reindex) supplies a reindex here. No-op when omitted — records are
+     * still picked up by the next index update.
+     */
+    reindex?(summary: MeetingsDayBuildSummary): void | Promise<void>;
+}
+/** Orchestrates a store-backed build of a day's meetings. */
+export declare class MeetingsBuilder {
+    private readonly opts;
+    constructor(opts: {
+        source: MeetingsDaySource;
+        store: MeetingRecordStore;
+        config: MeetingsConfig;
+        fusionOptions?: MeetingFusionOptions;
+        hooks?: MeetingsBuilderHooks;
+        /**
+         * When present, the memory-generation layer runs after the record-store
+         * writes: deterministic recall-anchor episodes per built record, the
+         * trust-gated summary/facts layer, and retract-on-removal — all behind the
+         * `MeetingMemoryGenerator` seam (issue #1900). Omitted → pure
+         * detect+fuse+store with no memory writes. The engine depends only on this
+         * interface, never on the memory-gen module.
+         */
+        memoryGenerator?: MeetingMemoryGenerator;
+    });
+    buildDay(date: string): Promise<MeetingsDayBuildSummary>;
+    /**
+     * Pick the existing same-day record whose window best overlaps `meeting` and
+     * reuse its id — but ONLY when adoption is safe: the windows substantially
+     * coincide (overlap covers a majority of the shorter window), OR a corroborating
+     * identity signal (same app, same title, or a shared transcript source) is
+     * BACKED by a non-marginal overlap (>= a quarter of the shorter window). Coarse
+     * identity signals alone never license adoption across a thin sliver of overlap,
+     * or two genuinely different back-to-back same-app meetings would overwrite each
+     * other's record and `show <old-id>` would point at the wrong meeting. Candidate
+     * selection is deterministic (max overlap, then earliest start, then id).
+     * Returns the detector's fresh id when nothing qualifies.
+     */
+    private adoptExistingId;
+}
+//# sourceMappingURL=build.d.ts.map

package/dist/meetings/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../../src/meetings/build.ts"],"names":[],"mappings":"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"}

package/dist/meetings/cli.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Meetings CLI runner (issue #1900) — one implementation shared by every CLI
+ * host (`remnic meetings ...` and `openclaw engram meetings ...`) so the
+ * surfaces never fork (same rule as the wearables/recall-explain runners).
+ *
+ * Flag validation is strict: value-taking flags require a value, unknown flags
+ * error with the valid list, malformed dates/ids reject loudly, and a missing
+ * record is a caller error — all `MeetingsInputError` → exit code 1 (CLAUDE.md
+ * rules 14 + 51). Backend faults bubble to the host's 500 handler.
+ */
+import type { MeetingsBuilder } from "./build.js";
+import { type MeetingRecordStore } from "./store.js";
+import type { MeetingsConfig } from "./types.js";
+export interface MeetingsCliIo {
+    stdout: {
+        write(chunk: string): unknown;
+    };
+    stderr: {
+        write(chunk: string): unknown;
+    };
+}
+/** Everything the runner drives. Injected so tests wire a store + builder over
+ *  synthetic fixtures with no real filesystem. */
+export interface MeetingsCliDeps {
+    store: MeetingRecordStore;
+    builder: MeetingsBuilder;
+    /**
+     * Meetings config, so list/show honor `meetings.enabled`. The runner reads the
+     * store directly (not through an enabled-aware service), so without this gate a
+     * disabled subsystem would still expose stored records via list/show even
+     * though `build` refuses. Disabled => no exposure (issue #1900).
+     */
+    config: MeetingsConfig;
+}
+/** Run a meetings CLI command. Returns a process exit code; all output via `io`. */
+export declare function runMeetingsCliCommand(deps: MeetingsCliDeps, args: string[], io: MeetingsCliIo): Promise<number>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/meetings/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/meetings/cli.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,eAAe,EAA2B,MAAM,YAAY,CAAC;AAE3E,OAAO,EAAiB,KAAK,kBAAkB,EAA6B,MAAM,YAAY,CAAC;AAC/F,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;IAC1C,MAAM,EAAE;QAAE,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAA;KAAE,CAAC;CAC3C;AAED;kDACkD;AAClD,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,kBAAkB,CAAC;IAC1B,OAAO,EAAE,eAAe,CAAC;IACzB;;;;;OAKG;IACH,MAAM,EAAE,cAAc,CAAC;CACxB;AA8FD,oFAAoF;AACpF,wBAAsB,qBAAqB,CACzC,IAAI,EAAE,eAAe,EACrB,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,EAAE,aAAa,GAChB,OAAO,CAAC,MAAM,CAAC,CA4GjB"}

package/dist/meetings/config.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Meetings config parsing — strict, loud, and default-safe (issue #1900).
+ *
+ * Mirrors the wearables/procedural blocks in config.ts: shape violations and
+ * unparseable values throw with actionable messages (CLAUDE.md rule 51);
+ * boolean-ish strings coerce via the shared helper (rule 36); every numeric
+ * knob is bounds-checked; the master gate defaults OFF (rule 48) so base
+ * installs see zero behavior change.
+ *
+ * This slice wires only the keys detection + fusion + the record store need.
+ * The memory-generation knobs (summaryMode, sourceTrust, autoApproveTrust,
+ * reviewTrust) land with the trust-pipeline slice.
+ */
+import type { MeetingsConfig } from "./types.js";
+export declare const DEFAULT_MEETINGS_CONFIG: MeetingsConfig;
+/** Parse the `meetings` config block. Absent/`{}` → defaults (subsystem off). */
+export declare function parseMeetingsConfig(value: unknown): MeetingsConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/meetings/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/meetings/config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,KAAK,EAAE,cAAc,EAAsB,MAAM,YAAY,CAAC;AAarE,eAAO,MAAM,uBAAuB,EAAE,cAYrC,CAAC;AA+EF,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,cAAc,CA6DlE"}

package/dist/meetings/day-source.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Concrete meetings day source (issue #1900) — the wiring slice that feeds the
+ * builder from the ESTABLISHED stores rather than fixtures:
+ *   - screen activity snapshots (the activity SQLite store), and
+ *   - wearable day transcripts (the wearable day-store), reconstructed into the
+ *     shared fusion conversation shape via `reconstructFusionInputs`.
+ *
+ * All timestamps stay UTC and every day read is a half-open [start, end)
+ * window resolved by `activityDayWindow(date, timezone)`, so the local day the
+ * caller asked for maps to one deterministic UTC window shared by both signals.
+ *
+ * Fidelity caveat (inherited, documented): a wearable day transcript is stored
+ * RENDERED at minute precision, so `reconstructFusionInputs` rebuilds each clock
+ * as `${date}THH:MM:00Z` — the same reconstruction the fusion subsystem uses.
+ * App spans come from true-UTC activity instants; the two frames coincide when
+ * the activity timezone is UTC (the default). Under a non-UTC timezone the
+ * app+audio overlap carries that reconstruction offset, exactly as wearable
+ * fusion does; audio-only detection is unaffected. Provider-meeting boundaries
+ * (Granola/Fireflies explicit titles) are a connector concern not present in the
+ * reconstructed day transcript, so audio windows never fabricate a provider flag.
+ */
+import type { ActivitySnapshot } from "../activity/types.js";
+import type { FusionConversationInput } from "../wearables/fusion/types.js";
+import type { MeetingDayData, MeetingsDaySource } from "./build.js";
+import type { MeetingAppSpan, MeetingAudioWindow, MeetingsConfig } from "./types.js";
+/** Reads the day's screen-activity snapshots. Satisfied by `ActivityStore`. */
+export interface MeetingsActivityReader {
+    /** Snapshots whose capture instant is in the half-open [start, end) window. */
+    listSnapshotsForDay(machine: string | null, startUtcInclusive: string, endUtcExclusive: string): ActivitySnapshot[] | Promise<ActivitySnapshot[]>;
+}
+/** One stored wearable day transcript body, ready for reconstruction. */
+export interface WearableDayBody {
+    source: string;
+    body: string;
+    escaped?: boolean;
+    /**
+     * IANA timezone the body's `HH:MM` clocks were rendered in (from the
+     * transcript frontmatter). Empty when the transcript stored no timezone —
+     * the clocks are then treated as UTC, matching the fusion identity guard.
+     */
+    timezone?: string;
+}
+/** Reads the day's rendered wearable transcript bodies (one per source). */
+export interface MeetingsWearableReader {
+    readDayBodies(date: string): Promise<WearableDayBody[]>;
+}
+/** Narrow slice of `StorageManager` the wearable reader needs. */
+export interface WearableDayTranscriptStore {
+    listWearableTranscriptDays(sourceId?: string): Promise<Array<{
+        source: string;
+        date: string;
+    }>>;
+    readWearableDayTranscript(sourceId: string, date: string): Promise<string | null>;
+}
+/**
+ * Build a wearable reader over a storage manager: discover which sources stored
+ * a transcript for the day (store-driven, not config-driven, so a day is read
+ * exactly from what exists on disk), then read + parse each body.
+ */
+export declare function storageWearableDayReader(store: WearableDayTranscriptStore): MeetingsWearableReader;
+/**
+ * Derive meeting-app foreground spans from the day's snapshots. A span is a
+ * maximal run of consecutive (time-ordered) snapshots on ONE capture machine
+ * whose app/title/url matches any configured pattern; the next non-matching
+ * snapshot ends the run AND bounds its end (so a lone matching snapshot still
+ * yields a non-zero span). A trailing run at the END of a machine's snapshots
+ * has no following non-matching tick to bound it, so a lone trailing tick is
+ * extended by the machine's sampling cadence rather than collapsing to a
+ * zero-length point the detector's `isFinitePair` rejects. Brief app switches
+ * during a call surface as adjacent spans and the detector's `mergeGapMinutes`
+ * re-merges them.
+ */
+export declare function deriveAppSpans(snapshots: readonly ActivitySnapshot[], appPatterns: readonly string[]): MeetingAppSpan[];
+/**
+ * Derive audio windows from reconstructed conversations. Each conversation is
+ * one window on its source; `distinctNonWearerSpeakers` counts distinct
+ * non-self speaker labels (the audio-only detection rule), and the end is the
+ * conversation end when known, else the latest segment instant, else the start.
+ */
+export declare function buildAudioWindows(conversations: readonly FusionConversationInput[]): MeetingAudioWindow[];
+/**
+ * Reads a day's real activity + wearable signals and assembles the
+ * {@link MeetingDayData} the builder consumes. Injected readers keep this
+ * testable against fixtures and free of direct filesystem access.
+ */
+export declare class ActivityWearablesMeetingsDaySource implements MeetingsDaySource {
+    private readonly deps;
+    constructor(deps: {
+        /**
+         * Screen-activity reader. Optional (issue #2123): only the machine-owner
+         * (default) namespace consumes machine-scoped activity; every other caller
+         * namespace runs audio-only, so it is constructed with no activity reader
+         * and the load degrades to zero screen snapshots.
+         */
+        activity?: MeetingsActivityReader;
+        wearables: MeetingsWearableReader;
+        config: MeetingsConfig;
+        /** IANA timezone resolving the local day → UTC window (activity's zone). */
+        timezone: string;
+    });
+    loadDayData(date: string): Promise<MeetingDayData>;
+}
+//# sourceMappingURL=day-source.d.ts.map

package/dist/meetings/day-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"day-source.d.ts","sourceRoot":"","sources":["../../src/meetings/day-source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAGH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D,OAAO,KAAK,EAAE,uBAAuB,EAAsB,MAAM,8BAA8B,CAAC;AAChG,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAEpE,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAClB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,+EAA+E;AAC/E,MAAM,WAAW,sBAAsB;IACrC,+EAA+E;IAC/E,mBAAmB,CACjB,OAAO,EAAE,MAAM,GAAG,IAAI,EACtB,iBAAiB,EAAE,MAAM,EACzB,eAAe,EAAE,MAAM,GACtB,gBAAgB,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAAC;CACrD;AAED,yEAAyE;AACzE,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,4EAA4E;AAC5E,MAAM,WAAW,sBAAsB;IACrC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAAC;CACzD;AAED,kEAAkE;AAClE,MAAM,WAAW,0BAA0B;IACzC,0BAA0B,CACxB,QAAQ,CAAC,EAAE,MAAM,GAChB,OAAO,CAAC,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IACpD,yBAAyB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CACnF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,0BAA0B,GAAG,sBAAsB,CAoBlG;AA8BD;;;;;;;;;;;GAWG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,SAAS,gBAAgB,EAAE,EACtC,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,cAAc,EAAE,CA4DlB;AA6DD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,aAAa,EAAE,SAAS,uBAAuB,EAAE,GAChD,kBAAkB,EAAE,CA+BtB;AAED;;;;GAIG;AACH,qBAAa,kCAAmC,YAAW,iBAAiB;IAExE,OAAO,CAAC,QAAQ,CAAC,IAAI;gBAAJ,IAAI,EAAE;QACrB;;;;;WAKG;QACH,QAAQ,CAAC,EAAE,sBAAsB,CAAC;QAClC,SAAS,EAAE,sBAAsB,CAAC;QAClC,MAAM,EAAE,cAAc,CAAC;QACvB,4EAA4E;QAC5E,QAAQ,EAAE,MAAM,CAAC;KAClB;IAGG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC;CAezD"}

package/dist/meetings/detect.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Retrospective meeting detection (issue #1900, Phase 4 slice 1).
+ *
+ * Pure functions over a day's already-ingested signals. A meeting candidate is
+ * either (a) an audio conversation overlapping a meeting-app foreground span
+ * (`app+audio`), (b) a provider meeting with its own boundaries (`provider`),
+ * or (c) a long enough multi-speaker conversation with no app span
+ * (`audio`, the phone-call/in-person fallback). App spans with no overlapping
+ * audio are NOT meetings (you were watching a recording). Candidates are then
+ * merged so a day's meetings never overlap, and each gets a re-run-stable id.
+ */
+import type { DetectedMeeting, MeetingsDetectionConfig, MeetingsDetectionInput } from "./types.js";
+/** Shipped meeting-app patterns (used by the later activity-span derivation). */
+export declare const DEFAULT_MEETING_APP_PATTERNS: readonly string[];
+export declare const DEFAULT_MEETINGS_DETECTION_CONFIG: MeetingsDetectionConfig;
+/** Re-run-stable id: same date + exact START instant ⇒ same id. Anchored on the
+ *  start ONLY (end + app both excluded from the hash) so a resync that extends
+ *  the meeting's end (a late source / rejoin) or reassigns its app never
+ *  renumbers an existing record — the start is the stable identity. Full start
+ *  precision (NOT minute-rounded) keeps ids unique even for short provider
+ *  meetings that share a start minute: post-merge meetings are non-overlapping,
+ *  so their start instants are always distinct.
+ *
+ *  A resync that moves a meeting's START earlier (a late source beginning before
+ *  the first-ingested one) does change the id — a stateless pure detector cannot
+ *  know the prior id. Preserving ids across a shifted start is cross-run identity
+ *  work that needs prior-emission state, so it belongs to the fusion/store slice
+ *  (#1900), which matches a re-detected meeting to its stored record by overlap
+ *  and keeps the original id. This function stays pure and deterministic. */
+export declare function meetingId(date: string, startUtc: string): string;
+/** Detect the day's non-overlapping meetings from its audio + app-span signals. */
+export declare function detectMeetings(input: MeetingsDetectionInput, config?: MeetingsDetectionConfig): DetectedMeeting[];
+//# sourceMappingURL=detect.d.ts.map

package/dist/meetings/detect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"detect.d.ts","sourceRoot":"","sources":["../../src/meetings/detect.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EACV,eAAe,EAIf,uBAAuB,EACvB,sBAAsB,EACvB,MAAM,YAAY,CAAC;AAEpB,iFAAiF;AACjF,eAAO,MAAM,4BAA4B,EAAE,SAAS,MAAM,EASzD,CAAC;AAEF,eAAO,MAAM,iCAAiC,EAAE,uBAK/C,CAAC;AAgCF;;;;;;;;;;;;;6EAa6E;AAC7E,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAWhE;AAkKD,mFAAmF;AACnF,wBAAgB,cAAc,CAC5B,KAAK,EAAE,sBAAsB,EAC7B,MAAM,GAAE,uBAA2D,GAClE,eAAe,EAAE,CAuBnB"}

package/dist/meetings/errors.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Error thrown by meeting surfaces for caller-correctable problems: invalid
+ * dates/ids, unknown commands/flags, or a missing record. Transport layers map
+ * this to 400-class responses; anything else is a backend fault (500). Mirrors
+ * `WearablesInputError` so the meetings surfaces follow the same house style.
+ */
+export declare class MeetingsInputError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/meetings/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/meetings/errors.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,qBAAa,kBAAmB,SAAQ,KAAK;gBAC/B,OAAO,EAAE,MAAM;CAI5B"}

package/dist/meetings/fuse.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Meeting fusion (issue #1900, Phase 4 slice 2).
+ *
+ * For a detected meeting window `[startUtc, endUtc)` (half-open, AGENTS.md §23),
+ * fuse the concurrent signals into a screen-aware `FusedMeeting`:
+ *
+ *   1. Transcript — clip every wearable source's segments to the window and run
+ *      them through the SHARED wearables reconciliation (`fuseCluster`). Higher-
+ *      `sourceTrust` text wins overlapping regions and the out-voted sources are
+ *      recorded per segment; this module never re-implements alignment/dedup —
+ *      the repo rule is "extend the shared fusion module, never fork it".
+ *   2. Screen context — other-app foreground dwell within the window, kept only
+ *      when it lasts `contextDwellSeconds`, plus deduped on-screen text excerpts
+ *      capped at `maxContextChars`.
+ *   3. Attendees — distinct non-wearer speaker labels from the fused transcript
+ *      (already resolved through the wearables speaker registry upstream).
+ *
+ * Pure and deterministic: same inputs ⇒ same `FusedMeeting`.
+ */
+import type { FusedMeeting, MeetingBuildInput, MeetingsConfig } from "./types.js";
+/** Per-run tuning that mirrors the wearables fusion knobs. */
+export interface MeetingFusionOptions {
+    /** Per-source trust priors handed to reconciliation. */
+    sourceTrust?: Record<string, number>;
+    /** Max drift (ms) for two segments to align across sources. */
+    windowToleranceMs?: number;
+}
+/** Fuse one detected meeting's transcript + screen context into a FusedMeeting. */
+export declare function fuseMeeting(input: MeetingBuildInput, config: MeetingsConfig, options?: MeetingFusionOptions): FusedMeeting;
+//# sourceMappingURL=fuse.d.ts.map

package/dist/meetings/fuse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fuse.d.ts","sourceRoot":"","sources":["../../src/meetings/fuse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAQH,OAAO,KAAK,EACV,YAAY,EACZ,iBAAiB,EAEjB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB,8DAA8D;AAC9D,MAAM,WAAW,oBAAoB;IACnC,wDAAwD;IACxD,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,+DAA+D;IAC/D,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAuMD,mFAAmF;AACnF,wBAAgB,WAAW,CACzB,KAAK,EAAE,iBAAiB,EACxB,MAAM,EAAE,cAAc,EACtB,OAAO,GAAE,oBAAyB,GACjC,YAAY,CA2Dd"}

package/dist/meetings/http-glue.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Meetings HTTP route glue (issue #1900) — the route bodies extracted from
+ * access-http.ts so the surface file stays under its structural ceiling. The
+ * thin inline hooks in access-http.ts keep the pathname/method match + the
+ * `enforceTokenOp("meetings_*")` boundary-dispatch marker (required by the
+ * surface-catalog fitness test) and delegate the body here.
+ *
+ * `MeetingsInputError` (invalid dates/ids) maps to a 400; everything else
+ * rethrows so backend faults keep flowing to the global 500 handler. Behaviour,
+ * validation, and `meetings.enabled` gating live in MeetingsService — these
+ * functions only translate transport shape.
+ */
+import type { IncomingMessage, ServerResponse } from "node:http";
+import { type WearablesMeetingsScope } from "../access-service.js";
+type RespondJson = (res: ServerResponse, status: number, payload: unknown) => void;
+type ReadJsonBody = (req: IncomingMessage) => Promise<unknown>;
+/** Minimal meetings surface the HTTP glue drives (satisfied by EngramAccessService). */
+export interface MeetingsHttpService {
+    meetingsList(date?: string, scope?: WearablesMeetingsScope): Promise<unknown>;
+    meetingsGet(id: string, scope?: WearablesMeetingsScope): Promise<unknown>;
+    meetingsBuild(date: string, scope?: WearablesMeetingsScope): Promise<unknown>;
+}
+/**
+ * Per-principal write-quota hooks the build route shares with every other
+ * mutating REST route: `enforceQuota` throws a 429 when the principal is over
+ * budget; `recordHit` accounts the successful write. Injected from access-http
+ * so the quota state stays owned by the server (issue #1937).
+ */
+export interface MeetingsWriteQuotaHooks {
+    enforceQuota(): void;
+    recordHit(): void;
+}
+export declare function respondMeetingsList(res: ServerResponse, respondJson: RespondJson, service: MeetingsHttpService, date: string | undefined, scope?: WearablesMeetingsScope): Promise<void>;
+export declare function respondMeetingsGet(res: ServerResponse, respondJson: RespondJson, service: MeetingsHttpService, rawId: string, scope?: WearablesMeetingsScope): Promise<void>;
+export declare function respondMeetingsBuild(req: IncomingMessage, res: ServerResponse, respondJson: RespondJson, readJsonBody: ReadJsonBody, service: MeetingsHttpService, quota: MeetingsWriteQuotaHooks, scopeFor?: (bodyNamespace?: string, bodySessionKey?: string) => WearablesMeetingsScope): Promise<void>;
+export {};
+//# sourceMappingURL=http-glue.d.ts.map

package/dist/meetings/http-glue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-glue.d.ts","sourceRoot":"","sources":["../../src/meetings/http-glue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,EAA0B,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAG3F,KAAK,WAAW,GAAG,CAAC,GAAG,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;AACnF,KAAK,YAAY,GAAG,CAAC,GAAG,EAAE,eAAe,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;AAE/D,wFAAwF;AACxF,MAAM,WAAW,mBAAmB;IAClC,YAAY,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9E,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC1E,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CAC/E;AAwBD;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,YAAY,IAAI,IAAI,CAAC;IACrB,SAAS,IAAI,IAAI,CAAC;CACnB;AAED,wBAAsB,mBAAmB,CACvC,GAAG,EAAE,cAAc,EACnB,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,MAAM,GAAG,SAAS,EACxB,KAAK,CAAC,EAAE,sBAAsB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,kBAAkB,CACtC,GAAG,EAAE,cAAc,EACnB,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,sBAAsB,GAC7B,OAAO,CAAC,IAAI,CAAC,CAOf;AAED,wBAAsB,oBAAoB,CACxC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,WAAW,EAAE,WAAW,EACxB,YAAY,EAAE,YAAY,EAC1B,OAAO,EAAE,mBAAmB,EAC5B,KAAK,EAAE,uBAAuB,EAC9B,QAAQ,CAAC,EAAE,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,cAAc,CAAC,EAAE,MAAM,KAAK,sBAAsB,GACrF,OAAO,CAAC,IAAI,CAAC,CA2Bf"}

package/dist/meetings/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Public entry for the retrospective meeting-detection subsystem (issue #1900):
+ * pure detection over a day's already-ingested audio + app-span signals.
+ * Re-exported from the package root (`src/index.ts`) so consumers import it from
+ * `@remnic/core`, matching the wearables/activity subsystems' surfacing.
+ */
+export * from "./types.js";
+export * from "./detect.js";
+export * from "./config.js";
+export * from "./errors.js";
+export * from "./fuse.js";
+export * from "./store.js";
+export * from "./memory-generator.js";
+export * from "./build.js";
+export * from "./memory-gen.js";
+export * from "./cli.js";
+export * from "./day-source.js";
+export * from "./build-scheduler.js";
+export * from "./service.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/meetings/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/meetings/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC"}

package/dist/meetings/mcp-tools.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Meetings MCP tool definitions (issue #1900) — the three `engram.meetings_*`
+ * tool-def objects, extracted from access-mcp.ts so the surface file stays under
+ * its structural ceiling. Spread back into `this.tools` (`...MEETINGS_MCP_TOOLS`);
+ * tools/list is verified at runtime. MCP_MIGRATED_OPERATIONS + callTool dispatch
+ * stay inline in access-mcp.ts.
+ */
+import type { McpTool } from "../access-mcp.js";
+export declare const MEETINGS_MCP_TOOLS: McpTool[];
+//# sourceMappingURL=mcp-tools.d.ts.map

package/dist/meetings/mcp-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tools.d.ts","sourceRoot":"","sources":["../../src/meetings/mcp-tools.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEhD,eAAO,MAAM,kBAAkB,EAAE,OAAO,EAsDvC,CAAC"}