@remnic/core 1.0.0

package/dist/storage.d.ts

@@ -0,0 +1,453 @@
+import { MemoryCategory, ImportanceScore, MemoryLink, MemoryFrontmatter, MemoryFile, BufferState, MetaState, MemoryActionEvent, MemoryLifecycleEvent, BehaviorSignalEvent, CompressionGuidelineOptimizerState, ContinuityIncidentOpenInput, ContinuityIncidentRecord, ContinuityIncidentCloseInput, ContinuityImprovementLoop, ContinuityLoopUpsertInput, ContinuityLoopReviewInput, FileHygieneConfig, EntityRelationship, EntityActivityEntry, EntityFile, PluginConfig, AccessTrackingEntry, MemoryProjectionCurrentState, MemorySummary, TopicScore } from './types.js';
+import { P as ProjectedMemoryBrowseOptions, i as ProjectedMemoryBrowsePage, j as readProjectedGovernanceRecord } from './memory-projection-store-NxMkbocT.js';
+import 'better-sqlite3';
+
+interface ReextractJobRequest {
+    memoryId: string;
+    model: string;
+    requestedAt: string;
+    source: "cli-migrate";
+}
+interface MemoryLifecycleEventWriteOptions {
+    at?: Date;
+    actor?: string;
+    reasonCode?: string;
+    ruleVersion?: string;
+    relatedMemoryIds?: string[];
+    correlationId?: string;
+}
+/**
+ * Normalize an entity name to a canonical form.
+ * Strips non-alphanumeric chars, collapses hyphens, removes type prefix duplication.
+ * e.g. "My Project" → "my-project"
+ *
+ * Checks user-defined aliases (from config/aliases.json) first, then built-in aliases.
+ */
+declare function normalizeEntityName(raw: string, type: string): string;
+/**
+ * Content-hash dedup index for facts.
+ * Normalizes content (lowercase, strip punctuation, collapse whitespace),
+ * computes SHA-256, and stores hashes in a line-delimited file.
+ * Prevents writing semantically identical facts.
+ */
+declare class ContentHashIndex {
+    private hashes;
+    private dirty;
+    private readonly filePath;
+    constructor(stateDir: string);
+    /** Load existing hashes from disk. Safe to call multiple times. */
+    load(): Promise<void>;
+    /** Check if content already exists in the index. */
+    has(content: string): boolean;
+    /** Add content hash to the index. */
+    add(content: string): void;
+    get size(): number;
+    /** Persist index to disk if changed. */
+    save(): Promise<void>;
+    /** Remove a hash from the index (used when archiving/deleting). */
+    remove(content: string): void;
+    /** Normalize content and compute SHA-256 hash. */
+    static normalizeContent(content: string): string;
+    /** Normalize content and compute SHA-256 hash. */
+    static computeHash(content: string): string;
+}
+/**
+ * Parse an entity markdown file into a structured EntityFile.
+ * Backward compatible: old files without new sections get empty arrays.
+ */
+declare function parseEntityFile(content: string): EntityFile;
+/**
+ * Serialize an EntityFile back to markdown.
+ * Only emits sections that have content (except Facts which is always emitted).
+ */
+declare function serializeEntityFile(entity: EntityFile): string;
+declare class StorageManager {
+    private readonly baseDir;
+    private knowledgeIndexCache;
+    private static readonly KNOWLEDGE_INDEX_CACHE_TTL_MS;
+    private artifactIndexCache;
+    private static readonly ARTIFACT_INDEX_CACHE_TTL_MS;
+    private static readonly artifactWriteVersionByDir;
+    private static readonly memoryStatusVersionByDir;
+    private static readonly allMemoriesInFlight;
+    private static readonly QUESTIONS_CACHE_TTL_MS;
+    private static readonly questionsCache;
+    private factHashIndex;
+    private factHashIndexLoadPromise;
+    private factHashIndexAuthoritative;
+    private factHashIndexAuthoritativePromise;
+    constructor(baseDir: string);
+    /** The root directory of this storage instance. */
+    get dir(): string;
+    private identityFilePath;
+    private versionFilePath;
+    private bumpSharedVersion;
+    private readSharedVersion;
+    private bumpMemoryStatusVersion;
+    getMemoryStatusVersion(): number;
+    private bumpArtifactWriteVersion;
+    private getArtifactWriteVersion;
+    private get factsDir();
+    private get correctionsDir();
+    private get entitiesDir();
+    private get stateDir();
+    private get factHashIndexReadyPath();
+    private getFactHashIndex;
+    private ensureFactHashIndexAuthoritative;
+    private get questionsDir();
+    private get artifactsDir();
+    private get identityDir();
+    private get identityAnchorPath();
+    private get identityIncidentsDir();
+    private get identityAuditsWeeklyDir();
+    private get identityAuditsMonthlyDir();
+    private get identityImprovementLoopsPath();
+    private get identityReflectionsPath();
+    private get profilePath();
+    private get memoryActionsPath();
+    private get memoryLifecycleLedgerPath();
+    private get compressionGuidelinesPath();
+    private get compressionGuidelineDraftPath();
+    private get compressionGuidelineStatePath();
+    private get compressionGuidelineDraftStatePath();
+    private get behaviorSignalsPath();
+    /**
+     * Load user-defined entity aliases from config/aliases.json in the memory store.
+     * File format: { "variant": "canonical", "variant2": "canonical", ... }
+     * Call this once at startup (e.g. from orchestrator.initialize()).
+     */
+    loadAliases(): Promise<void>;
+    ensureDirectories(): Promise<void>;
+    writeMemory(category: MemoryCategory, content: string, options?: {
+        actor?: string;
+        confidence?: number;
+        tags?: string[];
+        entityRef?: string;
+        source?: string;
+        supersedes?: string;
+        lineage?: string[];
+        importance?: ImportanceScore;
+        links?: MemoryLink[];
+        intentGoal?: string;
+        intentActionType?: string;
+        intentEntityTypes?: string[];
+        artifactType?: MemoryFrontmatter["artifactType"];
+        sourceMemoryId?: string;
+        sourceTurnId?: string;
+        memoryKind?: MemoryFrontmatter["memoryKind"];
+        expiresAt?: string;
+        structuredAttributes?: Record<string, string>;
+    }): Promise<string>;
+    hasFactContentHash(content: string): Promise<boolean>;
+    isFactContentHashAuthoritative(): Promise<boolean>;
+    writeArtifact(quote: string, options?: {
+        actor?: string;
+        tags?: string[];
+        confidence?: number;
+        artifactType?: MemoryFrontmatter["artifactType"];
+        sourceMemoryId?: string;
+        sourceTurnId?: string;
+        intentGoal?: string;
+        intentActionType?: string;
+        intentEntityTypes?: string[];
+    }): Promise<string>;
+    private readAllArtifactsCached;
+    searchArtifacts(query: string, maxResults: number): Promise<MemoryFile[]>;
+    writeEntity(name: string, type: string, facts: string[]): Promise<string>;
+    readProfile(): Promise<string>;
+    writeProfile(content: string): Promise<void>;
+    /**
+     * Normalize a string for fuzzy profile dedup: lowercase, strip punctuation, collapse whitespace.
+     */
+    private static normalizeForDedup;
+    /**
+     * Check if a new bullet is a fuzzy duplicate of any existing bullet.
+     * Returns true if the new bullet should be skipped.
+     */
+    private static isFuzzyDuplicate;
+    appendToProfile(updates: string[]): Promise<void>;
+    /** Check if profile.md exceeds the max line cap and needs LLM consolidation */
+    profileNeedsConsolidation(triggerLines?: number): Promise<boolean>;
+    readAllMemories(): Promise<MemoryFile[]>;
+    /** Invalidate the readAllMemories() cache after writes that add/remove memories. */
+    /** Public cache invalidation for callers that need authoritative disk reads
+     *  (e.g. projection verify/rebuild). */
+    invalidateAllMemoriesCacheForDir(): void;
+    /** Clear ALL static caches. Use in tests that write files directly
+     *  (bypassing StorageManager.writeMemory) to avoid stale reads. */
+    static clearAllStaticCaches(): void;
+    /** Cancel any in-flight concurrent read so the next readAllMemories()
+     *  starts a fresh disk scan and sees the just-written data. */
+    private invalidateAllMemoriesCache;
+    private normalizeMemoryReadBatchSize;
+    private collectActiveMemoryPaths;
+    private readParsedMemoriesFromPaths;
+    private readWindowUpdatedMs;
+    private filterWindowPathsByUpdatedAfter;
+    private orderWindowPaths;
+    private readWindowBoundedBatch;
+    readMemoriesWindow(options?: {
+        maxMemories?: number;
+        batchSize?: number;
+        updatedAfter?: Date;
+    }): Promise<{
+        memories: MemoryFile[];
+        filePaths: string[];
+    }>;
+    private _readAllMemoriesFromDisk;
+    /**
+     * Read archived memory markdown files under archive/.
+     * Used by long-term recall fallback when hot recall has no hits.
+     */
+    readArchivedMemories(): Promise<MemoryFile[]>;
+    /** Read a single memory file by its absolute path. Returns null if unreadable. */
+    readMemoryByPath(filePath: string): Promise<MemoryFile | null>;
+    private resolveTierRootDir;
+    private resolveMemoryDateDir;
+    private isArtifactMemory;
+    buildTierMemoryPath(memory: MemoryFile, tier: "hot" | "cold"): string;
+    private writeMemoryFileAtomic;
+    moveMemoryToPath(memory: MemoryFile, targetPath: string): Promise<void>;
+    migrateMemoryToTier(memory: MemoryFile, targetTier: "hot" | "cold"): Promise<{
+        changed: boolean;
+        targetPath: string;
+    }>;
+    private get archiveDir();
+    /**
+     * Archive a memory by moving it from facts/ to archive/YYYY-MM-DD/.
+     * Updates frontmatter with archived status before moving.
+     * Returns the new file path on success, null on failure.
+     */
+    archiveMemory(memory: MemoryFile, lifecycle?: MemoryLifecycleEventWriteOptions): Promise<string | null>;
+    readEntities(): Promise<string[]>;
+    readEntity(name: string): Promise<string>;
+    /** Return sorted list of entity filenames (without .md extension) */
+    listEntityNames(): Promise<string[]>;
+    /**
+     * Find an existing entity that fuzzy-matches the proposed name.
+     * Returns the existing entity filename (without .md) or null if no match.
+     *
+     * Matching priority:
+     * 1. Exact normalized match (handled by normalizeEntityName already)
+     * 2. Dehyphenated match: "jane-doe" vs "janedoe"
+     * 3. Substring containment: "handle-janedoe" contains "janedoe"
+     * 4. Levenshtein ≤ 2 on dehyphenated names
+     */
+    findMatchingEntity(proposedName: string, type: string): Promise<string | null>;
+    invalidateMemory(id: string): Promise<boolean>;
+    updateMemory(id: string, newContent: string, options?: {
+        supersedes?: string;
+        lineage?: string[];
+        actor?: string;
+    }): Promise<boolean>;
+    /**
+     * Update frontmatter fields without changing memory content.
+     * Returns false when the memory is not found.
+     */
+    writeMemoryFrontmatter(memory: MemoryFile, patch: Partial<MemoryFrontmatter>, lifecycle?: MemoryLifecycleEventWriteOptions): Promise<boolean>;
+    /**
+     * Update frontmatter by memory ID.
+     * Prefer writeMemoryFrontmatter(memory, patch) in batch loops to avoid full-corpus rescans.
+     */
+    updateMemoryFrontmatter(id: string, patch: Partial<MemoryFrontmatter>): Promise<boolean>;
+    /** Remove memories past their TTL expiresAt date */
+    cleanExpiredTTL(): Promise<MemoryFile[]>;
+    loadBuffer(): Promise<BufferState>;
+    saveBuffer(state: BufferState): Promise<void>;
+    loadMeta(): Promise<MetaState>;
+    saveMeta(state: MetaState): Promise<void>;
+    appendMemoryActionEvents(events: MemoryActionEvent[]): Promise<number>;
+    appendMemoryLifecycleEvents(events: MemoryLifecycleEvent[]): Promise<number>;
+    appendBehaviorSignals(events: BehaviorSignalEvent[]): Promise<number>;
+    appendReextractJobs(events: ReextractJobRequest[]): Promise<number>;
+    readReextractJobs(limit?: number): Promise<ReextractJobRequest[]>;
+    readBehaviorSignals(limit?: number): Promise<BehaviorSignalEvent[]>;
+    readMemoryActionEvents(limit?: number): Promise<MemoryActionEvent[]>;
+    readAllMemoryLifecycleEvents(): Promise<MemoryLifecycleEvent[]>;
+    readMemoryLifecycleEvents(limit?: number): Promise<MemoryLifecycleEvent[]>;
+    writeCompressionGuidelines(content: string): Promise<void>;
+    readCompressionGuidelines(): Promise<string | null>;
+    writeCompressionGuidelineDraft(content: string): Promise<void>;
+    readCompressionGuidelineDraft(): Promise<string | null>;
+    writeCompressionGuidelineOptimizerState(state: CompressionGuidelineOptimizerState): Promise<void>;
+    writeCompressionGuidelineDraftState(state: CompressionGuidelineOptimizerState): Promise<void>;
+    readCompressionGuidelineOptimizerState(): Promise<CompressionGuidelineOptimizerState | null>;
+    readCompressionGuidelineDraftState(): Promise<CompressionGuidelineOptimizerState | null>;
+    activateCompressionGuidelineDraft(options?: {
+        expectedContentHash?: string;
+        expectedGuidelineVersion?: number;
+    }): Promise<boolean>;
+    private readCompressionGuidelineStateFile;
+    writeIdentityAnchor(content: string): Promise<void>;
+    readIdentityAnchor(): Promise<string | null>;
+    appendContinuityIncident(input: ContinuityIncidentOpenInput): Promise<ContinuityIncidentRecord>;
+    readContinuityIncidents(limit?: number, state?: "open" | "closed" | "all"): Promise<ContinuityIncidentRecord[]>;
+    closeContinuityIncident(id: string, closure: ContinuityIncidentCloseInput): Promise<ContinuityIncidentRecord | null>;
+    writeIdentityAudit(period: "weekly" | "monthly", key: string, content: string): Promise<string>;
+    readIdentityAudit(period: "weekly" | "monthly", key: string): Promise<string | null>;
+    writeIdentityImprovementLoops(content: string): Promise<void>;
+    readIdentityImprovementLoops(): Promise<string | null>;
+    readIdentityImprovementLoopRegister(): Promise<ContinuityImprovementLoop[]>;
+    upsertIdentityImprovementLoop(input: ContinuityLoopUpsertInput): Promise<ContinuityImprovementLoop>;
+    reviewIdentityImprovementLoop(id: string, input: ContinuityLoopReviewInput): Promise<ContinuityImprovementLoop | null>;
+    private generateId;
+    private readContinuityIncidentFileNames;
+    private readContinuityIncidentFile;
+    private findContinuityIncidentFilePathById;
+    private sanitizeIdentityAuditKey;
+    writeQuestion(question: string, context: string, priority: number): Promise<string>;
+    readQuestions(opts?: {
+        unresolvedOnly?: boolean;
+    }): Promise<Array<{
+        id: string;
+        question: string;
+        context: string;
+        priority: number;
+        resolved: boolean;
+        created: string;
+        filePath: string;
+    }>>;
+    /** Invalidate the questions cache (call after writing a question). */
+    invalidateQuestionsCache(): void;
+    private parseQuestionFile;
+    private extractFrontmatterValue;
+    resolveQuestion(id: string): Promise<boolean>;
+    readIdentity(workspaceDir: string, namespace?: string): Promise<string>;
+    writeIdentity(workspaceDir: string, content: string, namespace?: string): Promise<void>;
+    /** Max size for IDENTITY.md before we stop appending reflections (15KB leaves room under 20KB gateway limit) */
+    private static readonly IDENTITY_MAX_BYTES;
+    /** Minimum interval between reflections (1 hour) */
+    private static readonly REFLECTION_COOLDOWN_MS;
+    appendToIdentity(workspaceDir: string, reflection: string, opts?: {
+        hygiene?: FileHygieneConfig;
+        namespace?: string;
+    }): Promise<void>;
+    readIdentityReflections(): Promise<string | null>;
+    writeIdentityReflections(content: string): Promise<void>;
+    appendIdentityReflection(reflection: string): Promise<void>;
+    /**
+     * Add a relationship to an entity file.
+     * Deduplicates by target+label.
+     */
+    addEntityRelationship(name: string, rel: EntityRelationship): Promise<void>;
+    /**
+     * Add an activity entry to an entity file.
+     * Prepends to the beginning, prunes oldest entries beyond maxEntries.
+     */
+    addEntityActivity(name: string, entry: EntityActivityEntry, maxEntries: number): Promise<void>;
+    /**
+     * Add an alias to an entity file. Deduplicates.
+     */
+    addEntityAlias(name: string, alias: string): Promise<void>;
+    /**
+     * Set or update the summary of an entity file.
+     */
+    updateEntitySummary(name: string, summary: string): Promise<void>;
+    /**
+     * Read all entity files and return lightweight EntityFile objects.
+     * Parsing is fast (~50-100ms for ~1,800 files) since entity files are small.
+     */
+    readAllEntityFiles(): Promise<EntityFile[]>;
+    /**
+     * Score an entity based on recency, frequency, activity, type priority,
+     * and relationship density.
+     *
+     * score = recency*0.40 + frequency*0.25 + activity*0.15 + typePriority*0.10 + relationshipDensity*0.10
+     */
+    static scoreEntity(entity: EntityFile, now: Date): number;
+    /**
+     * Build the Knowledge Index: a compact markdown table of top-scored entities.
+     * Respects maxEntities and maxChars limits from config.
+     */
+    buildKnowledgeIndex(config: PluginConfig, overrides?: {
+        maxEntities?: number;
+        maxChars?: number;
+    }): Promise<{
+        result: string;
+        cached: boolean;
+    }>;
+    /** Invalidate the Knowledge Index cache (call after entity mutations). */
+    invalidateKnowledgeIndexCache(): void;
+    /** Max lines for profile.md before LLM consolidation triggers */
+    private static readonly PROFILE_MAX_LINES;
+    /**
+     * Merge fragmented entity files that resolve to the same canonical name.
+     * Preserves relationships, activity, aliases, and summary from all fragments.
+     * Returns count of files merged.
+     */
+    mergeFragmentedEntities(): Promise<number>;
+    cleanExpiredCommitments(decayDays: number): Promise<MemoryFile[]>;
+    /**
+     * Flush batched access tracking updates to disk.
+     * Called during consolidation or when buffer exceeds max size.
+     */
+    flushAccessTracking(entries: AccessTrackingEntry[]): Promise<number>;
+    /**
+     * Get a memory by its ID.
+     */
+    getMemoryById(id: string): Promise<MemoryFile | null>;
+    getProjectedMemoryState(id: string): Promise<MemoryProjectionCurrentState | null>;
+    browseProjectedMemories(options: ProjectedMemoryBrowseOptions): Promise<ProjectedMemoryBrowsePage | null>;
+    getProjectedGovernanceRecord(): Promise<ReturnType<typeof readProjectedGovernanceRecord>>;
+    private toProjectedCurrentState;
+    getMemoryTimeline(memoryId: string, limit?: number): Promise<MemoryLifecycleEvent[]>;
+    /**
+     * Write a memory chunk with parent reference.
+     * Chunk IDs follow format: {parentId}-chunk-{index}
+     */
+    writeChunk(parentId: string, chunkIndex: number, chunkTotal: number, category: MemoryCategory, content: string, options?: {
+        confidence?: number;
+        tags?: string[];
+        entityRef?: string;
+        source?: string;
+        importance?: ImportanceScore;
+        intentGoal?: string;
+        intentActionType?: string;
+        intentEntityTypes?: string[];
+        memoryKind?: MemoryFrontmatter["memoryKind"];
+    }): Promise<string>;
+    /**
+     * Get all chunks for a given parent memory ID.
+     * Returns chunks sorted by chunkIndex.
+     */
+    getChunksForParent(parentId: string): Promise<MemoryFile[]>;
+    /**
+     * Mark a memory as superseded by another.
+     * Updates the old memory's status and adds the supersededBy link.
+     */
+    supersedeMemory(oldMemoryId: string, newMemoryId: string, reason: string): Promise<boolean>;
+    private get summariesDir();
+    /**
+     * Write a memory summary.
+     */
+    writeSummary(summary: MemorySummary): Promise<void>;
+    /**
+     * Get all summaries.
+     */
+    readSummaries(): Promise<MemorySummary[]>;
+    /**
+     * Archive memories (mark as archived, not delete).
+     */
+    archiveMemories(memoryIds: string[], summaryId: string): Promise<number>;
+    /**
+     * Save topic scores to meta.json.
+     */
+    saveTopics(topics: TopicScore[]): Promise<void>;
+    /**
+     * Load topic scores from meta.json.
+     */
+    loadTopics(): Promise<{
+        topics: TopicScore[];
+        updatedAt: string | null;
+    }>;
+    /**
+     * Add links to an existing memory.
+     */
+    addLinksToMemory(memoryId: string, links: MemoryLink[], lifecycle?: MemoryLifecycleEventWriteOptions): Promise<boolean>;
+    private summarizeLifecycleState;
+    private frontmatterPatchEventType;
+    private appendGeneratedMemoryLifecycleEvent;
+    private appendGeneratedMemoryLifecycleEventFailOpen;
+}
+
+export { ContentHashIndex, type MemoryLifecycleEventWriteOptions, type ReextractJobRequest, StorageManager, normalizeEntityName, parseEntityFile, serializeEntityFile };

package/dist/storage.js

@@ -0,0 +1,24 @@
+import {
+  ContentHashIndex,
+  StorageManager,
+  normalizeEntityName,
+  parseEntityFile,
+  serializeEntityFile
+} from "./chunk-QWUUMMIK.js";
+import "./chunk-U4PV25RD.js";
+import "./chunk-ESSMF2FR.js";
+import "./chunk-TP4FZJIZ.js";
+import "./chunk-SCU65EZI.js";
+import "./chunk-BOUYNNYD.js";
+import "./chunk-DM2T26WE.js";
+import "./chunk-QSVPYQPG.js";
+import "./chunk-M62O4P4T.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  ContentHashIndex,
+  StorageManager,
+  normalizeEntityName,
+  parseEntityFile,
+  serializeEntityFile
+};
+//# sourceMappingURL=storage.js.map

package/dist/storage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/store-contract.d.ts

@@ -0,0 +1,10 @@
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+declare function assertString(value: unknown, field: string): string;
+declare function optionalString(value: unknown): string | undefined;
+declare function assertSafePathSegment(value: string, field: string): string;
+declare function assertIsoRecordedAt(value: string, field?: string): string;
+declare function recordStoreDay(recordedAt: string): string;
+declare function optionalStringArray(value: unknown, field: string): string[] | undefined;
+declare function validateStringRecord(raw: unknown, field?: string): Record<string, string> | undefined;
+
+export { assertIsoRecordedAt, assertSafePathSegment, assertString, isRecord, optionalString, optionalStringArray, recordStoreDay, validateStringRecord };

package/dist/store-contract.js

@@ -0,0 +1,21 @@
+import {
+  assertIsoRecordedAt,
+  assertSafePathSegment,
+  assertString,
+  isRecord,
+  optionalString,
+  optionalStringArray,
+  recordStoreDay,
+  validateStringRecord
+} from "./chunk-DGXUHMOV.js";
+export {
+  assertIsoRecordedAt,
+  assertSafePathSegment,
+  assertString,
+  isRecord,
+  optionalString,
+  optionalStringArray,
+  recordStoreDay,
+  validateStringRecord
+};
+//# sourceMappingURL=store-contract.js.map

package/dist/store-contract.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/summarizer.d.ts

@@ -0,0 +1,35 @@
+import { ModelRegistry } from './model-registry.js';
+import { PluginConfig, GatewayConfig, TranscriptEntry, HourlySummary } from './types.js';
+import { TranscriptManager } from './transcript.js';
+import './session-integrity.js';
+
+declare class HourlySummarizer {
+    private summariesDir;
+    private config;
+    private localLlm;
+    private fallbackLlm;
+    private modelRegistry;
+    private transcript?;
+    constructor(config: PluginConfig, gatewayConfig?: GatewayConfig, modelRegistry?: ModelRegistry, transcript?: TranscriptManager);
+    private get useGatewayModelSource();
+    private get shouldUseLocalLlm();
+    private withGatewayAgent;
+    initialize(): Promise<void>;
+    generateSummary(sessionKey: string, hourStart: Date, entries: TranscriptEntry[]): Promise<HourlySummary | null>;
+    private generateExtended;
+    /**
+     * Generate summary using local LLM with JSON mode.
+     * Uses dynamic context sizing based on model capabilities.
+     */
+    private generateWithLocalLlm;
+    saveSummary(summary: HourlySummary): Promise<void>;
+    private formatHourSection;
+    readRecent(sessionKey: string, hours: number): Promise<HourlySummary[]>;
+    private parseSummaryFile;
+    formatForRecall(summaries: HourlySummary[], maxCount: number): string;
+    runHourly(): Promise<void>;
+    private getActiveSessions;
+    private getTranscriptEntries;
+}
+
+export { HourlySummarizer };

package/dist/summarizer.js

@@ -0,0 +1,17 @@
+import {
+  HourlySummarizer
+} from "./chunk-CDW777AI.js";
+import "./chunk-ETOW6ACV.js";
+import "./chunk-ONRU4L2N.js";
+import "./chunk-MDDAA2AO.js";
+import "./chunk-LK6SGL53.js";
+import "./chunk-KT4NEUNF.js";
+import "./chunk-LU3GQNDQ.js";
+import "./chunk-Y27UJK6V.js";
+import "./chunk-UZB5KHKX.js";
+import "./chunk-MARWOCVP.js";
+import "./chunk-KWBU5S5U.js";
+export {
+  HourlySummarizer
+};
+//# sourceMappingURL=summarizer.js.map

package/dist/summarizer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/summary-snapshot.d.ts

@@ -0,0 +1,8 @@
+import { HourlySummary } from './types.js';
+
+declare function summarySnapshotPath(memoryDir: string, sessionKey: string): string;
+declare function readSummarySnapshot(memoryDir: string, sessionKey: string): Promise<HourlySummary[] | null>;
+declare function writeSummarySnapshot(memoryDir: string, sessionKey: string, summaries: HourlySummary[]): Promise<void>;
+declare function upsertSummarySnapshot(memoryDir: string, summary: HourlySummary): Promise<void>;
+
+export { readSummarySnapshot, summarySnapshotPath, upsertSummarySnapshot, writeSummarySnapshot };

package/dist/summary-snapshot.js

@@ -0,0 +1,13 @@
+import {
+  readSummarySnapshot,
+  summarySnapshotPath,
+  upsertSummarySnapshot,
+  writeSummarySnapshot
+} from "./chunk-ETOW6ACV.js";
+export {
+  readSummarySnapshot,
+  summarySnapshotPath,
+  upsertSummarySnapshot,
+  writeSummarySnapshot
+};
+//# sourceMappingURL=summary-snapshot.js.map

package/dist/summary-snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}