@dsh-agentic-roleplay/state 0.1.1 → 0.2.1

package/README.md

@@ -66,7 +66,7 @@ The package owns how a story is remembered, not only where it is stored:
 - `session.records(scope)` reads the records back in the same wire format.
 - `session.recall({ characterId, situation, turn, policy })` is what a character is reminded of: events it took in and things it believes, by who the situation mentions, shared words and tags, importance and story-time recency; with `policy.flaky` the older and less important are told as faded or vague, or are gone. Age is elapsed story time from `session.clock`, never turn count; an unimportant event has a six-story-day half-life. It counts what it brings back as recalled, which makes it last longer.
 - `session.recallStored(query, { queryVector? })` adds the session's search index to the cues: texts that match the situation by words and, with the vector of the situation, by meaning. `session.searchEvents({ text, vector?, fromTurn, toTurn, minImportance, limit })` finds what happened by the same two searches, merged by reciprocal rank.
-- `session.recallRanked(query, signal, { queryVector? })` is the call for anything that reminds a character of something: `recall`, ranked by meaning when a plugin has registered a ranker with `roleplayState.rankMemories(ranker)` (an embedding model, a reranker; see `docs/capabilities.md`). `session.recallCandidates(query)` gives what could be recalled, with the text to match, for a ranker.
+- `session.recallRanked(query, signal, { queryVector? })` is the call for anything that reminds a character of something: `recall`, ranked by meaning when a plugin has registered a ranker with `roleplayState.rankMemories(ranker)` (an embedding model, a reranker; see `docs/capabilities.md`). `session.recallCandidates(query)` gives what could be recalled, with the text to match, for a ranker. With `explain: true` in the query each recalled thing carries `why`: the cues of the moment (people named, words shared, place), what each search scored it, how much it matters, how long ago it was, how much of it is left in mind and what it was ranked by.
 - `session.knowledge` is the closed-world awareness graph for locations, items and directed exits (`learn`, `knows`, `get`, `list`, `forget`). Directional relationships are the corresponding character-to-character edges. Awareness grants identity only, not current state or whereabouts. `session.planKnownMove` plans through only a character's known places and exits; `planMove` remains the authoritative world planner.
 - `session.factions`, `factionStates`, `factionMemberships`, `factionRelationships` and `factionIntents` store persistent organisations separately from characters that act in scenes. Membership is many-to-many; relationships involving factions are directional and double as closed-world awareness edges.
 - `roleplayState.bind(resolver)` tells the tools which roleplay session an agent works in (the plugin that runs the agents supplies it, with the turn being played and the memory policy).
@@ -153,6 +153,12 @@ once released: a change is a new entry in `src/sqlite/schema.ts`, and a test
 pins the migrations of each release. A database from a newer version is refused
 rather than damaged.
 
+Before a file that is behind the latest schema is upgraded, it must pass SQLite's
+quick integrity check (a damaged file is refused with `CorruptDataError`, untouched)
+and a copy of it as it was is written to `migration-backups/schema-<version>.sqlite`
+beside the database, once per old version. `migrationBackupPath(location, version)`
+says where.
+
 ## Errors
 
 | Error | When |

package/lib/index.d.ts

@@ -2502,6 +2502,16 @@ interface MemoryPolicy {
    * reranker judges, and it also gives importance and recency something to choose between. At least 1.
    */
   overRetrieve?: number;
+  /**
+   * How many more things come to mind because they are strongly tied to what the moment recalled (the same people together with the same
+   * place or tags) and matter enough. 0 or absent: none.
+   */
+  associate?: number;
+  /**
+   * How much a memory that says what one already chosen says counts against it, from 0 (the best by score, repeats
+   * included) to 1 (only what adds something new): maximal marginal relevance over the pool. 0 or absent: none.
+   */
+  diversity?: number;
 }
 declare const DEFAULT_MEMORY_POLICY: MemoryPolicy;
 /** How much of a memory is left: what the character is told of it. */
@@ -2519,6 +2529,38 @@ interface Recalled {
     kind: 'perception' | 'memory';
     id: number;
   };
+  /** It did not match the moment itself: it came to mind with something that did ({@link MemoryPolicy.associate}). */
+  linked?: true;
+  /** Why it came back, when the query asked to be told ({@link RecallQuery.explain}). */
+  why?: RecallWhy;
+}
+/** What made one thing come back, for finding out why a character was or was not reminded of something. */
+interface RecallWhy {
+  /** What the cues of the moment gave, in the units of a cue: people named (a name counts 3, more for social weight), words and tags shared (at most 6), being where it happened. */
+  cues: {
+    people: number;
+    words: number;
+    place: number;
+  };
+  /** What each search scored it, from 0 to 1; absent when that search did not run or did not find it. */
+  lexical?: number;
+  dense?: number;
+  rerank?: number;
+  /** What it counted for in the end: the fused retrieval score, blended with the reranker's when there was one. */
+  relevance: number;
+  importance: number;
+  /** How long ago it was in story days; 0 when the story has no clock. */
+  ageDays: number;
+  /** How much of it is left in mind, from 1 to 0, when memories fade. */
+  retention?: number;
+  /** What it was ranked by, together with how much it matters and how recent it is. */
+  score: number;
+  /** For something that came to mind with another: what it shares with the closest of the things recalled for the moment. */
+  linked?: {
+    people: number;
+    tags: number;
+    place: boolean;
+  };
 }
 interface RecallQuery {
   characterId: CharacterId;
@@ -2530,6 +2572,10 @@ interface RecallQuery {
   locationId?: number;
   turn: number;
   policy: MemoryPolicy;
+  /** Say why each thing came back ({@link Recalled.why}). */
+  explain?: boolean;
+  /** Only what involves or is about one of these people comes back: "what do I know about her", which a name in the words would not reliably find. */
+  about?: readonly CharacterId[];
 }
 /** What recall reads: the events a character took in and what it believes. */
 interface RecallSource {
@@ -2556,14 +2602,22 @@ declare function clarityAt(value: number, importance: number): Clarity | undefin
 declare function tokens(text: string): Set<string>;
 /** The characters a text mentions by name or alias. */
 declare function mentioned(text: string, characters: readonly Character[]): Set<number>;
+/** What ties a candidate to others: the people it involves (other than the one remembering), its tags and where it happened. */
+interface Links {
+  people: readonly number[];
+  tags: readonly string[];
+  place?: number;
+}
 interface Candidate {
   key: string;
-  recalled: Omit<Recalled, 'clarity' | 'text'> & {
+  links: Links;
+  recalled: Omit<Recalled, 'clarity' | 'text' | 'why'> & {
     clear: string;
     faded: string;
     vague: string;
   };
   relevance: number;
+  cues: RecallWhy['cues'];
   importance: number;
   ageDays: number;
   recalls: number;
@@ -2592,7 +2646,7 @@ interface RecallEvidence {
   rerank?: ReadonlyMap<string, number>;
 }
 /** Everything the character could be reminded of, for a caller that ranks by meaning (an embedding, a reranker) before asking for the recall. */
-declare function recallCandidates(source: RecallSource, query: Pick<RecallQuery, 'characterId' | 'characters' | 'situation' | 'turn' | 'locationId'>): RecallCandidate[];
+declare function recallCandidates(source: RecallSource, query: Pick<RecallQuery, 'characterId' | 'characters' | 'situation' | 'turn' | 'locationId' | 'about'>): RecallCandidate[];
 /** Fuse scores from 0 to 1 into one, per key: the weighted average over the searches that ran (those with any score above 0). */
 declare function fuseScores(searches: readonly {
   weight: number;
@@ -2602,11 +2656,18 @@ interface PoolEntry {
   candidate: Candidate;
   /** How well retrieval alone matches the moment, from 0 to 1. */
   fused: number;
+  /** What each search scored it, when it was found by it. */
+  found: {
+    lexical?: number;
+    dense?: number;
+  };
 }
 /** What retrieval over-retrieved for one recall, waiting for a reranker's judgement and the final choice. */
 interface RecallPool {
   entries: readonly PoolEntry[];
-  query: Pick<RecallQuery, 'policy'>;
+  /** What retrieval left out, which an association may still bring to mind. */
+  others: readonly Candidate[];
+  query: Pick<RecallQuery, 'policy' | 'explain'>;
 }
 /**
  * The first stage of reminding a character of what the moment calls to mind: retrieve, by the cues
@@ -2619,7 +2680,7 @@ declare function recallPool(source: RecallSource, query: RecallQuery, evidence?:
 /** What a reranker is asked to judge: every candidate of the pool, with the text it would be recalled by. */
 declare function poolCandidates(pool: RecallPool): RecallCandidate[];
 /**
- * The last stage: choose the `policy.recall` best of the pool. With a reranker's judgement each
+ * The last stage: choose the `policy.recall` best of the pool, spread by `policy.diversity`. With a reranker's judgement each
  * candidate's relevance is mostly that (a candidate it left out counts as 0), and the rest is what
  * retrieval found; without, it is what retrieval found.
  */
@@ -2963,6 +3024,10 @@ declare function createSessionStore(location: string, session: NewSession, optio
  * @throws {SchemaError} when the file is not a session database, or is from a newer version.
  */
 declare function openSessionStore(location: string, options?: StoreOptions): SessionStore;
+/** Folder, beside the database, holding the copies made before a schema upgrade. */
+declare const MIGRATION_BACKUP_FOLDER = "migration-backups";
+/** Where the copy of a database as it was at schema `version` is kept. */
+declare function migrationBackupPath(location: string, version: number): string;
 //#endregion
 //#region src/sessions.d.ts
 declare const SESSION_DATABASE_FILE = "session.sqlite";
@@ -3308,5 +3373,5 @@ type LintTarget = Pick<RecordsTarget, 'characters' | 'locations' | 'placements'
  */
 declare function lintWorld(target: LintTarget): LintFinding[];
 //#endregion
-export { ACCURACIES, Accuracy, type Agenda, type AgendaEngagement, type AgendaOptions, type AgentLink, type AgentResolver, type Announcement, type BeliefEdit, CHARACTER_CONTROLS, CHARACTER_KINDS, CHARACTER_ROLES, CHARACTER_TIERS, CLOCK_MODES, COMPARISONS, CONSOLIDATION_KINDS, CONTAINER_STATES, Character, CharacterControl, CharacterDefinition, CharacterFilter, CharacterId, CharacterIntent, CharacterKind, CharacterMemory, CharacterMemoryPatch, type CharacterMove, CharacterPatch, type CharacterRepository, CharacterRole, CharacterSpeech, CharacterStart, CharacterState, CharacterStatePatch, type CharacterStateRepository, CharacterTier, type Clarity, type Clock, ClockMode, ClockState, Comparison, Config, ConflictError, ConsolidationItem, ConsolidationItemId, ConsolidationKind, type ConsolidationRepository, ContainerSpec, ContainerState, CorruptDataError, DAY, DAY_PARTS, DEFAULT_MEMORY_POLICY, DEFAULT_SLOTS, type DayPart, EMOTION_VARIABLES, ENGAGEMENT_GRACE, ENGAGEMENT_STATUSES, EXIT_STATES, type EditChecker, type EditResult, EmbeddingIndexInfo, EmotionStart, EmotionVector, Engagement, EngagementFilter, EngagementId, EngagementPatch, EngagementStatus, EntityKnowledge, type EventEdit, EventId, type EventRepository, Exit, type ExitChange, ExitDefinition, ExitId, ExitOpener, ExitPatch, ExitState, Faction, FactionDefinition, FactionId, FactionIntent, type FactionIntentRepository, FactionMembership, FactionMembershipDefinition, type FactionMembershipRepository, FactionPatch, FactionRelationship, FactionRelationshipDefinition, type FactionRelationshipRepository, type FactionRepository, FactionState, FactionStatePatch, type FactionStateRepository, type FiredTrigger, HOUR, Holder, Holding, IMPORTANCE_MAX, IMPORTANCE_MIN, INTENT_HORIZONS, INTENT_STATUSES, INTENT_TYPES, ITEM_ACTIONS, Intent, IntentFilter, IntentHorizon, IntentId, IntentPatch, type IntentRepository, IntentStatus, IntentType, InvalidEditError, InvalidMoveError, InvalidValueError, Item, type ItemAction, type ItemChange, type ItemChangeSpec, type ItemContext, ItemDefinition, type ItemEditSpec, type ItemEffect, ItemId, ItemPatch, type ItemPlan, type ItemRepository, JsonValue, KNOWLEDGE_KINDS, KnowledgeDefinition, KnowledgeKind, type KnowledgeRepository, type KnownMoveContext, LORE_KINDS, LORE_SUBJECT_KINDS, type LintFinding, type LintSeverity, type LintTarget, type LocalTime, Location, LocationDefinition, LocationFeature, LocationId, LocationPatch, type LocationRepository, Lore, LoreDefinition, LoreId, LoreKind, LorePatch, LoreSubject, LoreSubjectDefinition, LoreSubjectKind, MAX_LOCATION_FEATURES, MAX_ROUTINE_WINDOWS, MAX_SHOWN, MAX_TRIGGERS, MAX_VARIABLES, MEMBERSHIP_STATUSES, MEMORY_KINDS, MINUTE, MembershipPatch, MembershipStatus, MemoryId, MemoryKind, type MemoryPolicy, type MemoryRepository, type MetadataRepository, Move, type MoveContext, MovePlan, type NewBelief, NewCharacter, NewCharacterMemory, type NewCharacterSpec, NewCharacterState, NewEngagement, type NewEvent, NewExit, type NewExitBetween, type NewExit$1 as NewExitEdit, NewFaction, NewFactionState, NewItem, type NewItemSpec, NewLocation, NewLore, NewPerception, type NewPlace, NewPlacement, NewRelationship, NewSession, NewStoryEvent, NewSummary, NewTriggerNote, NotFoundError, type Occurrence, type OpenOptions, PERCEPTION_MODES, PLACEABLE_KINDS, PLOT_NUDGE_MODES, PLOT_STATUSES, PendingCommit, type PendingCommitRepository, PendingEmbedding, type PerceivedBy, PerceivedEvent, Perception, type PerceptionAddition, type PerceptionEdit, PerceptionId, PerceptionMode, PerceptionPatch, type PlaceEdit, PlaceableKind, Placement, type PlacementRepository, PlotDefinition, PlotDevelopment, PlotNudgeMode, PlotProgress, PlotStatus, RECALL_ITEM_KINDS, type RankedGoal, type RecallCandidate, type RecallEvidence, RecallHit, type RecallIndexRepository, RecallItemKind, type RecallPool, type RecallQuery, type RecallSearch, type RecallSource, type Recalled, type RecordsEdit, type RecordsScope, type RecordsTarget, type RecordsView, Relationship, RelationshipDefinition, RelationshipId, RelationshipPatch, type RelationshipRepository, type RelationshipRetraction, type RelationshipSet, RoleplayState, RoutineDefinition, RoutineWindow, type RunResult, LATEST_VERSION as SCHEMA_VERSION, SECOND, SESSION_DATABASE_FILE, SLOT_ID, SUMMARY_LEVELS, SchemaError, type SemanticRanker, type Session, type SessionInit, type SessionListing, SessionMetadata, type SessionStore, type ShownVariable, Slot, type SlotRepository, SocialSubjectKind, type SqlDatabase, type SqlDriver, type SqlValue, StateError, type StatePatch, type StoreOptions, StoredRoutineWindow, StoredVariable, StoryEvent, StoryEventFilter, StoryEventPatch, StoryThread, Summary, SummaryId, SummaryLevel, type SummaryRepository, THREAD_STATUSES, TIME_CHANGE_KINDS, TRIGGER_NOTE_KINDS, TRIGGER_STATUSES, ThreadId, type ThreadRepository, ThreadStatus, TimeChange, TimeChangeFilter, TimeChangeKind, Trigger, TriggerAnnouncement, TriggerAudience, type TriggerClock, TriggerCondition, TriggerDefinition, TriggerEffect, TriggerId, TriggerNote, TriggerNoteKind, type TriggerRun, type TriggerRunOptions, TriggerStatus, VARIABLE_KEY, VARIABLE_KINDS, VARIABLE_SUBJECTS, VARIABLE_VISIBILITIES, VISUAL_SUBJECT_KINDS, type VariableAudience, VariableBand, type VariableChangeSpec, type VariableContext, VariableDefinition, VariableDefinitionInput, type VariableEffect, VariableKind, type VariablePlan, VariableSubject, VariableValue, VariableVisibility, type VectorSearch, type VectorSupport, VisualIdentity, VisualIdentityInput, VisualIdentityPatch, type VisualIdentityRepository, VisualSubjectKind, WEEKDAY_NAMES, WorldReference, addLocalDays, agendaAt, announcements, apply, applyItemPlan, applyRecordsEdit, audienceIds, catchUpPlan, changeItem, changeVariable, characterKey, clarityAt, clockTime, conditionHolds, createCharacterTools, createSession, createSessionStore, createTools, dayPart, deleteSession, denseScore, describeDuration, describeHolder, describeInstant, describeValue, finishRecall, fuseScores, inAudience, inWindow, isSessionId, isTimeZone, itemKey, jitter, judgedStatements, lapseNotes, lintWorld, listSessions, localIso, localTime, locationKey, mentioned, moveCharacter, name, nextOccurrence, nextTimeOfDay, nodeSqliteDriver, occurrenceAt, openSession, openSessionStore, overlap, parseInstant, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, retention, runTriggers, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemTimeZone, tokens, triggerReferenceProblems, valueIssue, zonedInstant };
+export { ACCURACIES, Accuracy, type Agenda, type AgendaEngagement, type AgendaOptions, type AgentLink, type AgentResolver, type Announcement, type BeliefEdit, CHARACTER_CONTROLS, CHARACTER_KINDS, CHARACTER_ROLES, CHARACTER_TIERS, CLOCK_MODES, COMPARISONS, CONSOLIDATION_KINDS, CONTAINER_STATES, Character, CharacterControl, CharacterDefinition, CharacterFilter, CharacterId, CharacterIntent, CharacterKind, CharacterMemory, CharacterMemoryPatch, type CharacterMove, CharacterPatch, type CharacterRepository, CharacterRole, CharacterSpeech, CharacterStart, CharacterState, CharacterStatePatch, type CharacterStateRepository, CharacterTier, type Clarity, type Clock, ClockMode, ClockState, Comparison, Config, ConflictError, ConsolidationItem, ConsolidationItemId, ConsolidationKind, type ConsolidationRepository, ContainerSpec, ContainerState, CorruptDataError, DAY, DAY_PARTS, DEFAULT_MEMORY_POLICY, DEFAULT_SLOTS, type DayPart, EMOTION_VARIABLES, ENGAGEMENT_GRACE, ENGAGEMENT_STATUSES, EXIT_STATES, type EditChecker, type EditResult, EmbeddingIndexInfo, EmotionStart, EmotionVector, Engagement, EngagementFilter, EngagementId, EngagementPatch, EngagementStatus, EntityKnowledge, type EventEdit, EventId, type EventRepository, Exit, type ExitChange, ExitDefinition, ExitId, ExitOpener, ExitPatch, ExitState, Faction, FactionDefinition, FactionId, FactionIntent, type FactionIntentRepository, FactionMembership, FactionMembershipDefinition, type FactionMembershipRepository, FactionPatch, FactionRelationship, FactionRelationshipDefinition, type FactionRelationshipRepository, type FactionRepository, FactionState, FactionStatePatch, type FactionStateRepository, type FiredTrigger, HOUR, Holder, Holding, IMPORTANCE_MAX, IMPORTANCE_MIN, INTENT_HORIZONS, INTENT_STATUSES, INTENT_TYPES, ITEM_ACTIONS, Intent, IntentFilter, IntentHorizon, IntentId, IntentPatch, type IntentRepository, IntentStatus, IntentType, InvalidEditError, InvalidMoveError, InvalidValueError, Item, type ItemAction, type ItemChange, type ItemChangeSpec, type ItemContext, ItemDefinition, type ItemEditSpec, type ItemEffect, ItemId, ItemPatch, type ItemPlan, type ItemRepository, JsonValue, KNOWLEDGE_KINDS, KnowledgeDefinition, KnowledgeKind, type KnowledgeRepository, type KnownMoveContext, LORE_KINDS, LORE_SUBJECT_KINDS, type LintFinding, type LintSeverity, type LintTarget, type LocalTime, Location, LocationDefinition, LocationFeature, LocationId, LocationPatch, type LocationRepository, Lore, LoreDefinition, LoreId, LoreKind, LorePatch, LoreSubject, LoreSubjectDefinition, LoreSubjectKind, MAX_LOCATION_FEATURES, MAX_ROUTINE_WINDOWS, MAX_SHOWN, MAX_TRIGGERS, MAX_VARIABLES, MEMBERSHIP_STATUSES, MEMORY_KINDS, MIGRATION_BACKUP_FOLDER, MINUTE, MembershipPatch, MembershipStatus, MemoryId, MemoryKind, type MemoryPolicy, type MemoryRepository, type MetadataRepository, Move, type MoveContext, MovePlan, type NewBelief, NewCharacter, NewCharacterMemory, type NewCharacterSpec, NewCharacterState, NewEngagement, type NewEvent, NewExit, type NewExitBetween, type NewExit$1 as NewExitEdit, NewFaction, NewFactionState, NewItem, type NewItemSpec, NewLocation, NewLore, NewPerception, type NewPlace, NewPlacement, NewRelationship, NewSession, NewStoryEvent, NewSummary, NewTriggerNote, NotFoundError, type Occurrence, type OpenOptions, PERCEPTION_MODES, PLACEABLE_KINDS, PLOT_NUDGE_MODES, PLOT_STATUSES, PendingCommit, type PendingCommitRepository, PendingEmbedding, type PerceivedBy, PerceivedEvent, Perception, type PerceptionAddition, type PerceptionEdit, PerceptionId, PerceptionMode, PerceptionPatch, type PlaceEdit, PlaceableKind, Placement, type PlacementRepository, PlotDefinition, PlotDevelopment, PlotNudgeMode, PlotProgress, PlotStatus, RECALL_ITEM_KINDS, type RankedGoal, type RecallCandidate, type RecallEvidence, RecallHit, type RecallIndexRepository, RecallItemKind, type RecallPool, type RecallQuery, type RecallSearch, type RecallSource, type RecallWhy, type Recalled, type RecordsEdit, type RecordsScope, type RecordsTarget, type RecordsView, Relationship, RelationshipDefinition, RelationshipId, RelationshipPatch, type RelationshipRepository, type RelationshipRetraction, type RelationshipSet, RoleplayState, RoutineDefinition, RoutineWindow, type RunResult, LATEST_VERSION as SCHEMA_VERSION, SECOND, SESSION_DATABASE_FILE, SLOT_ID, SUMMARY_LEVELS, SchemaError, type SemanticRanker, type Session, type SessionInit, type SessionListing, SessionMetadata, type SessionStore, type ShownVariable, Slot, type SlotRepository, SocialSubjectKind, type SqlDatabase, type SqlDriver, type SqlValue, StateError, type StatePatch, type StoreOptions, StoredRoutineWindow, StoredVariable, StoryEvent, StoryEventFilter, StoryEventPatch, StoryThread, Summary, SummaryId, SummaryLevel, type SummaryRepository, THREAD_STATUSES, TIME_CHANGE_KINDS, TRIGGER_NOTE_KINDS, TRIGGER_STATUSES, ThreadId, type ThreadRepository, ThreadStatus, TimeChange, TimeChangeFilter, TimeChangeKind, Trigger, TriggerAnnouncement, TriggerAudience, type TriggerClock, TriggerCondition, TriggerDefinition, TriggerEffect, TriggerId, TriggerNote, TriggerNoteKind, type TriggerRun, type TriggerRunOptions, TriggerStatus, VARIABLE_KEY, VARIABLE_KINDS, VARIABLE_SUBJECTS, VARIABLE_VISIBILITIES, VISUAL_SUBJECT_KINDS, type VariableAudience, VariableBand, type VariableChangeSpec, type VariableContext, VariableDefinition, VariableDefinitionInput, type VariableEffect, VariableKind, type VariablePlan, VariableSubject, VariableValue, VariableVisibility, type VectorSearch, type VectorSupport, VisualIdentity, VisualIdentityInput, VisualIdentityPatch, type VisualIdentityRepository, VisualSubjectKind, WEEKDAY_NAMES, WorldReference, addLocalDays, agendaAt, announcements, apply, applyItemPlan, applyRecordsEdit, audienceIds, catchUpPlan, changeItem, changeVariable, characterKey, clarityAt, clockTime, conditionHolds, createCharacterTools, createSession, createSessionStore, createTools, dayPart, deleteSession, denseScore, describeDuration, describeHolder, describeInstant, describeValue, finishRecall, fuseScores, inAudience, inWindow, isSessionId, isTimeZone, itemKey, jitter, judgedStatements, lapseNotes, lintWorld, listSessions, localIso, localTime, locationKey, mentioned, migrationBackupPath, moveCharacter, name, nextOccurrence, nextTimeOfDay, nodeSqliteDriver, occurrenceAt, openSession, openSessionStore, overlap, parseInstant, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, retention, runTriggers, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemTimeZone, tokens, triggerReferenceProblems, valueIssue, zonedInstant };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
 import { DatabaseSync } from "node:sqlite";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
 import { randomUUID } from "node:crypto";
@@ -1922,9 +1922,15 @@ function describeValue(def, value) {
 	const band = def.bands.find((candidate) => value <= candidate.upTo) ?? def.bands.at(-1);
 	return band === void 0 ? shortNumber(value) : `${band.label} (${shortNumber(value)})`;
 }
+/** A variable written by its name or in other letter case ("Valence" for `valence`), when exactly one variable has that name or key. */
+function namedVariable(variables, written) {
+	const wanted = written.trim().normalize("NFKC").toLowerCase();
+	const found = wanted === "" ? [] : variables.defs().filter((def) => def.key.normalize("NFKC").toLowerCase() === wanted || def.name.normalize("NFKC").toLowerCase() === wanted);
+	return found.length === 1 ? found[0] : void 0;
+}
 /** Whether a change can be made, and what it would come to. Nothing is changed. */
 function planVariableChange(context, spec) {
-	const def = context.variables.def(spec.variable);
+	const def = context.variables.def(spec.variable) ?? namedVariable(context.variables, spec.variable);
 	if (def === void 0) return {
 		ok: false,
 		problems: [`there is no variable "${spec.variable}" (list_variables shows them)`]
@@ -5210,7 +5216,9 @@ const DAY$1 = 864e5;
 const DEFAULT_MEMORY_POLICY = {
 	flaky: true,
 	recall: 12,
-	overRetrieve: 4
+	overRetrieve: 4,
+	associate: 2,
+	diversity: .3
 };
 /** Story days for the memory of an unimportant event to halve; each step of importance doubles it. */
 const HALF_LIFE_DAYS = 6;
@@ -5341,7 +5349,7 @@ const DENSE_RANGE = .5;
 const denseScore = (similarity) => Math.min(1, Math.max(0, (similarity - DENSE_FLOOR) / DENSE_RANGE));
 /** Being where something happened calls it to mind, about as much as sharing two words with it. */
 const PLACE_CUE = 2;
-function gather(source, { characterId, characters, situation, locationId }) {
+function gather(source, { characterId, characters, situation, locationId, about }) {
 	const names = new Map(characters.map((character) => [character.id, character.name]));
 	const peers = mentioned(situation, characters);
 	peers.delete(characterId);
@@ -5359,24 +5367,46 @@ function gather(source, { characterId, characters, situation, locationId }) {
 	}
 	const atTurn = (eventTurn) => turns.get(eventTurn) ?? start;
 	const ageDays = (at) => now === void 0 || at === void 0 ? 0 : Math.max(0, now - at) / DAY$1;
-	return [...source.events.perceivedBy(characterId).map((seen) => {
+	const concerns = (ids) => about === void 0 || about.length === 0 || ids.some((id) => about.includes(id));
+	return [...source.events.perceivedBy(characterId).filter((seen) => concerns(seen.event.involves)).map((seen) => {
 		const at = rounds.get(`${seen.event.turn}:${seen.event.round}`) ?? atTurn(seen.event.turn);
+		const cue = {
+			people: peopleCue(seen.event.involves),
+			words: overlap(cues, `${seen.perception.content} ${seen.event.text}`, seen.event.tags),
+			place: locationId !== void 0 && seen.event.locationId === locationId ? PLACE_CUE : 0
+		};
 		return {
 			key: `p:${seen.perception.id}`,
+			links: {
+				people: seen.event.involves.filter((id) => id !== characterId),
+				tags: seen.event.tags.map((tag) => tag.toLowerCase()),
+				...seen.event.locationId === void 0 ? {} : { place: seen.event.locationId }
+			},
 			recalled: describeEvent(seen, names, at),
-			relevance: peopleCue(seen.event.involves) + overlap(cues, `${seen.perception.content} ${seen.event.text}`, seen.event.tags) + (locationId !== void 0 && seen.event.locationId === locationId ? PLACE_CUE : 0),
+			cues: cue,
+			relevance: cue.people + cue.words + cue.place,
 			importance: seen.event.importance,
 			ageDays: ageDays(at),
 			recalls: seen.perception.recalls,
 			seed: seen.perception.id,
 			durability: 1
 		};
-	}), ...source.memories.list(characterId).map((belief) => {
+	}), ...source.memories.list(characterId).filter((belief) => concerns(belief.about)).map((belief) => {
 		const at = atTurn(belief.turn);
+		const cue = {
+			people: peopleCue(belief.about),
+			words: overlap(cues, belief.text, []),
+			place: 0
+		};
 		return {
 			key: `m:${belief.id}`,
+			links: {
+				people: belief.about.filter((id) => id !== characterId),
+				tags: []
+			},
 			recalled: describeBelief(belief, at),
-			relevance: peopleCue(belief.about) + overlap(cues, belief.text, []),
+			cues: cue,
+			relevance: cue.people + cue.words,
 			importance: belief.importance,
 			ageDays: ageDays(at),
 			recalls: belief.recalls,
@@ -5405,20 +5435,25 @@ function fuseScores(searches) {
 /** How well a candidate stands once its relevance is known: what the moment calls to mind, how much it matters and how recent it is. */
 function judged(candidate, relevance, policy) {
 	let clarity = "clear";
-	if (policy.flaky) clarity = clarityAt(retention({
-		ageDays: candidate.ageDays,
-		importance: candidate.importance,
-		recalls: candidate.recalls,
-		seed: candidate.seed,
-		durability: candidate.durability,
-		cue: relevance >= CUE_RELEVANCE
-	}), candidate.importance);
+	let kept;
+	if (policy.flaky) {
+		kept = retention({
+			ageDays: candidate.ageDays,
+			importance: candidate.importance,
+			recalls: candidate.recalls,
+			seed: candidate.seed,
+			durability: candidate.durability,
+			cue: relevance >= CUE_RELEVANCE
+		});
+		clarity = clarityAt(kept, candidate.importance);
+	}
 	if (clarity === void 0) return void 0;
 	const score = RELEVANCE_SCALE * relevance + .6 * candidate.importance + 2 / (1 + Math.max(0, candidate.ageDays)) + (clarity === "vague" ? -1 : 0);
 	return {
 		clarity,
 		score,
-		text: candidate.recalled[clarity === "clear" ? "clear" : clarity === "faded" ? "faded" : "vague"]
+		text: candidate.recalled[clarity === "clear" ? "clear" : clarity === "faded" ? "faded" : "vague"],
+		...kept === void 0 ? {} : { retention: kept }
 	};
 }
 /**
@@ -5429,7 +5464,7 @@ function judged(candidate, relevance, policy) {
 * is, and not what has faded from memory altogether). A reranker may then judge that pool.
 */
 function recallPool(source, query, evidence = {}) {
-	const { policy } = query;
+	const { policy, explain } = query;
 	const candidates = gather(source, query);
 	const fused = fuseScores([
 		{
@@ -5446,18 +5481,28 @@ function recallPool(source, query, evidence = {}) {
 		}
 	]);
 	const width = Math.min(MAX_POOL, Math.max(policy.recall, Math.ceil(policy.recall * Math.max(1, policy.overRetrieve ?? 1))));
+	const entries = candidates.map((candidate) => ({
+		candidate,
+		fused: fused.get(candidate.key) ?? 0,
+		found: {
+			...evidence.lexical?.get(candidate.key) === void 0 ? {} : { lexical: evidence.lexical.get(candidate.key) },
+			...evidence.dense?.get(candidate.key) === void 0 ? {} : { dense: evidence.dense.get(candidate.key) }
+		}
+	})).flatMap((entry) => {
+		const standing = judged(entry.candidate, entry.fused, policy);
+		return standing === void 0 ? [] : [{
+			entry,
+			score: standing.score
+		}];
+	}).sort((a, b) => b.score - a.score || b.entry.candidate.recalled.turn - a.entry.candidate.recalled.turn).map(({ entry }) => entry).slice(0, width);
+	const kept = new Set(entries.map((entry) => entry.candidate.key));
 	return {
-		entries: candidates.map((candidate) => ({
-			candidate,
-			fused: fused.get(candidate.key) ?? 0
-		})).flatMap((entry) => {
-			const standing = judged(entry.candidate, entry.fused, policy);
-			return standing === void 0 ? [] : [{
-				entry,
-				score: standing.score
-			}];
-		}).sort((a, b) => b.score - a.score || b.entry.candidate.recalled.turn - a.entry.candidate.recalled.turn).slice(0, width).map(({ entry }) => entry),
-		query: { policy }
+		entries,
+		others: candidates.filter((candidate) => !kept.has(candidate.key)),
+		query: {
+			policy,
+			...explain === true ? { explain } : {}
+		}
 	};
 }
 /** What a reranker is asked to judge: every candidate of the pool, with the text it would be recalled by. */
@@ -5469,26 +5514,129 @@ function poolCandidates(pool) {
 		importance: candidate.importance
 	}));
 }
+/** Two things are tied by the same people, the same tags and the same place; this is how strongly (people count most, tags and place add a little). */
+function tie(a, b) {
+	const people = a.people.filter((id) => b.people.includes(id)).length;
+	const tags = a.tags.filter((tag) => b.tags.includes(tag)).length;
+	const place = a.place !== void 0 && a.place === b.place;
+	return {
+		strength: 2 * Math.min(people, 2) + Math.min(tags, 2) + (place ? 1 : 0),
+		people,
+		tags,
+		place
+	};
+}
+/** The least a tie has to be for one thing to bring the other to mind. */
+const STRONG_TIE = 3;
+/** What does not matter much is not brought back by association. */
+const ASSOCIABLE_IMPORTANCE = 3;
+/** How much two texts say the same, from 0 to 1: the share of their words (or pairs of characters) they have in common. */
+function resemblance(a, b) {
+	if (a.size === 0 || b.size === 0) return 0;
+	let shared = 0;
+	for (const word of a) if (b.has(word)) shared++;
+	return shared / (a.size + b.size - shared);
+}
+/**
+* Choose `count` of the ranked entries by maximal marginal relevance: each pick is the one with the best score
+* discounted by how much it resembles what is already chosen, so that three memories of the same moment do not
+* crowd out one of another. `diversity` 0 keeps the ranking as it is.
+*/
+function diversified(ranked, count, diversity) {
+	const weight = Math.min(1, Math.max(0, diversity));
+	if (weight === 0 || ranked.length <= 1) return ranked.slice(0, count);
+	const top = Math.max(...ranked.map((entry) => entry.score), Number.EPSILON);
+	const words = new Map(ranked.map((entry) => [entry, tokens(entry.candidate.recalled.clear)]));
+	const left = [...ranked];
+	const chosen = [];
+	while (chosen.length < count && left.length > 0) {
+		let best = 0;
+		let bestValue = -Infinity;
+		left.forEach((entry, index) => {
+			const repeat = Math.max(0, ...chosen.map((picked) => resemblance(words.get(entry), words.get(picked))));
+			const value = (1 - weight) * Math.max(0, entry.score) / top - weight * repeat;
+			if (value > bestValue) {
+				best = index;
+				bestValue = value;
+			}
+		});
+		chosen.push(left.splice(best, 1)[0]);
+	}
+	return chosen;
+}
 /**
-* The last stage: choose the `policy.recall` best of the pool. With a reranker's judgement each
+* The last stage: choose the `policy.recall` best of the pool, spread by `policy.diversity`. With a reranker's judgement each
 * candidate's relevance is mostly that (a candidate it left out counts as 0), and the rest is what
 * retrieval found; without, it is what retrieval found.
 */
 function finishRecall(pool, rerank) {
 	const { policy } = pool.query;
-	return pool.entries.flatMap(({ candidate, fused }) => {
-		const standing = judged(candidate, rerank === void 0 ? fused : RERANK_BLEND * Math.min(1, Math.max(0, rerank.get(candidate.key) ?? 0)) + .30000000000000004 * fused, policy);
-		return standing === void 0 ? [] : [{
+	const standing = pool.entries.flatMap(({ candidate, fused, found }) => {
+		const relevance = rerank === void 0 ? fused : RERANK_BLEND * Math.min(1, Math.max(0, rerank.get(candidate.key) ?? 0)) + .30000000000000004 * fused;
+		const judgement = judged(candidate, relevance, policy);
+		if (judgement === void 0) return [];
+		const why = pool.query.explain === true ? {
+			cues: candidate.cues,
+			...found,
+			...rerank === void 0 ? {} : { rerank: rerank.get(candidate.key) ?? 0 },
+			relevance,
+			importance: candidate.importance,
+			ageDays: candidate.ageDays,
+			...judgement.retention === void 0 ? {} : { retention: judgement.retention },
+			score: judgement.score
+		} : void 0;
+		return [{
 			candidate,
-			...standing
+			relevance,
+			...judgement,
+			why
 		}];
-	}).sort((a, b) => b.score - a.score || b.candidate.recalled.turn - a.candidate.recalled.turn).slice(0, policy.recall).sort((a, b) => a.candidate.recalled.turn - b.candidate.recalled.turn).map(({ candidate, clarity, text }) => ({
+	}).sort((a, b) => b.score - a.score || b.candidate.recalled.turn - a.candidate.recalled.turn);
+	const chosen = diversified(standing, policy.recall, policy.diversity ?? 0);
+	const result = chosen.map(({ candidate, clarity, text, why }) => ({
 		clarity,
 		text,
 		turn: candidate.recalled.turn,
 		...candidate.recalled.at === void 0 ? {} : { at: candidate.recalled.at },
-		source: candidate.recalled.source
+		source: candidate.recalled.source,
+		...why === void 0 ? {} : { why }
 	}));
+	const anchors = chosen.filter((entry) => entry.relevance >= CUE_RELEVANCE);
+	const wanted = anchors.length === 0 ? 0 : Math.max(0, policy.associate ?? 0);
+	if (wanted > 0) {
+		const taken = new Set(chosen.map((entry) => entry.candidate.key));
+		const tied = [...standing.filter((entry) => !chosen.includes(entry)).map((entry) => entry.candidate), ...pool.others].filter((candidate) => !taken.has(candidate.key) && candidate.importance >= ASSOCIABLE_IMPORTANCE).flatMap((candidate) => {
+			const best = anchors.map((anchor) => tie(anchor.candidate.links, candidate.links)).sort((a, b) => b.strength - a.strength)[0];
+			const judgement = best === void 0 || best.strength < STRONG_TIE ? void 0 : judged(candidate, 0, policy);
+			return best === void 0 || judgement === void 0 || judgement.clarity === "vague" ? [] : [{
+				candidate,
+				best,
+				judgement
+			}];
+		}).sort((a, b) => b.best.strength - a.best.strength || b.candidate.importance - a.candidate.importance || b.candidate.recalled.turn - a.candidate.recalled.turn).slice(0, wanted);
+		for (const { candidate, best, judgement } of tied) result.push({
+			clarity: judgement.clarity,
+			text: judgement.text,
+			turn: candidate.recalled.turn,
+			...candidate.recalled.at === void 0 ? {} : { at: candidate.recalled.at },
+			source: candidate.recalled.source,
+			linked: true,
+			...pool.query.explain === true ? { why: {
+				cues: candidate.cues,
+				relevance: 0,
+				importance: candidate.importance,
+				ageDays: candidate.ageDays,
+				...judgement.retention === void 0 ? {} : { retention: judgement.retention },
+				score: judgement.score,
+				linked: {
+					people: best.people,
+					tags: best.tags,
+					place: best.place
+				}
+			} } : {}
+		});
+	}
+	return result.sort((a, b) => a.turn - b.turn);
 }
 /** Remind a character of what the moment calls to mind, in one call: {@link recallPool}, then {@link finishRecall} with the `rerank` evidence if there is any. */
 function recall(source, query, evidence = {}) {
@@ -9169,6 +9317,7 @@ function openSessionStore(location, options = {}) {
 	try {
 		const state = inspect(db);
 		if (state.version === 0 || state.applicationId !== 1146245971) throw new SchemaError(`${location} is not a session database`);
+		if (state.version < LATEST_VERSION && location !== ":memory:") backUpBeforeMigrating(db, location, state.version);
 		migrate(db);
 		return new SqliteSessionStore(db, options.clock ?? systemClock, vectors);
 	} catch (error) {
@@ -9176,6 +9325,24 @@ function openSessionStore(location, options = {}) {
 		throw error;
 	}
 }
+/** Folder, beside the database, holding the copies made before a schema upgrade. */
+const MIGRATION_BACKUP_FOLDER = "migration-backups";
+/** Where the copy of a database as it was at schema `version` is kept. */
+function migrationBackupPath(location, version) {
+	return join(dirname(location), MIGRATION_BACKUP_FOLDER, `schema-${version}.sqlite`);
+}
+/**
+* A released session cannot be rebuilt, so an upgrade starts from a copy that passed the integrity check; one copy per old version is kept.
+* @throws {CorruptDataError} when the database is damaged, before anything is changed.
+*/
+function backUpBeforeMigrating(db, location, version) {
+	const check = db.get("PRAGMA quick_check")?.quick_check;
+	if (check !== "ok") throw new CorruptDataError(`${location} failed its integrity check, so it was not upgraded: ${check ?? "no result"}`);
+	const target = migrationBackupPath(location, version);
+	if (existsSync(target)) return;
+	mkdirSync(dirname(target), { recursive: true });
+	db.run("VACUUM INTO ?", [target]);
+}
 //#endregion
 //#region src/sessions.ts
 const SESSION_DATABASE_FILE = "session.sqlite";
@@ -11192,11 +11359,17 @@ function createCharacterTools(link, characterId) {
 		defineTool({
 			name: "recall_my_memories",
 			description: "Ask yourself what you remember about something: a person, an object, a place or an earlier moment. You get your own version of it, what you took in yourself and what you believe, and what has faded comes back as hazy or not at all. Use it only when you need a memory that the situation does not already give you.",
-			parameters: { about: {
-				type: "string",
-				required: true,
-				description: "What to remember: a name, an object, a topic or a short description of the moment."
-			} },
+			parameters: {
+				about: {
+					type: "string",
+					required: true,
+					description: "What to remember: a name, an object, a topic or a short description of the moment."
+				},
+				person: {
+					type: "string",
+					description: "Only what concerns this person (a name or alias you know): everything you remember of them."
+				}
+			},
 			output: {
 				schema: {
 					type: "array",
@@ -11221,20 +11394,24 @@ function createCharacterTools(link, characterId) {
 				},
 				render: (_args, value) => [{
 					type: "text",
-					text: value.length === 0 ? "You do not remember anything about that." : value.map((entry) => `- (${entry.clarity === "clear" ? "" : entry.clarity === "faded" ? "the details are fuzzy" : "you barely remember"}) ${entry.text}`.replace("- () ", "- ")).join("\n")
+					text: value.length === 0 ? "You do not remember anything about that, and there is nothing more to find: go on with what you know." : value.map((entry) => `- (${entry.clarity === "clear" ? "" : entry.clarity === "faded" ? "the details are fuzzy" : "you barely remember"}) ${entry.text}`.replace("- () ", "- ")).join("\n")
 				}]
 			},
 			isConcurrencySafe: () => false,
 			async execute(args, exec) {
 				const agent = link();
 				const { session, turn, policy } = agent;
+				const who = args.person === void 0 || args.person.trim() === "" ? [] : [...mentioned(args.person, session.characters.list())].filter((id) => id !== characterId);
+				if (args.person !== void 0 && args.person.trim() !== "" && who.length === 0) return [];
+				const situation = who.length === 0 ? args.about : `${args.about} ${args.person}`;
 				return (await session.recallRanked({
 					characterId,
-					situation: args.about,
+					situation,
 					turn,
 					policy,
+					...who.length === 0 ? {} : { about: who },
 					...placeOf(session, characterId)
-				}, exec.signal, await vectorOf(agent, args.about, exec.signal))).map((entry) => ({
+				}, exec.signal, await vectorOf(agent, situation, exec.signal))).map((entry) => ({
 					clarity: entry.clarity,
 					turn: entry.turn,
 					text: entry.text
@@ -11272,7 +11449,7 @@ function createCharacterTools(link, characterId) {
 				},
 				render: (_args, value) => [{
 					type: "text",
-					text: value.length === 0 ? "You know of nothing matching that." : value.map((entry) => `- ${entry.kind}: ${entry.name} (${entry.key})`).join("\n")
+					text: value.length === 0 ? "You know of nothing matching that." : value.map((entry) => `- ${entry.kind}: ${entry.name}`).join("\n")
 				}]
 			},
 			isConcurrencySafe: () => true,
@@ -11383,6 +11560,6 @@ function createCharacterTools(link, characterId) {
 	];
 }
 //#endregion
-export { ACCURACIES, CHARACTER_CONTROLS, CHARACTER_KINDS, CHARACTER_ROLES, CHARACTER_TIERS, CLOCK_MODES, COMPARISONS, CONSOLIDATION_KINDS, CONTAINER_STATES, Config, ConflictError, CorruptDataError, DAY, DAY_PARTS, DEFAULT_MEMORY_POLICY, DEFAULT_SLOTS, EMOTION_VARIABLES, ENGAGEMENT_GRACE, ENGAGEMENT_STATUSES, EXIT_STATES, HOUR, IMPORTANCE_MAX, IMPORTANCE_MIN, INTENT_HORIZONS, INTENT_STATUSES, INTENT_TYPES, ITEM_ACTIONS, InvalidEditError, InvalidMoveError, InvalidValueError, KNOWLEDGE_KINDS, LORE_KINDS, LORE_SUBJECT_KINDS, MAX_LOCATION_FEATURES, MAX_ROUTINE_WINDOWS, MAX_SHOWN, MAX_TRIGGERS, MAX_VARIABLES, MEMBERSHIP_STATUSES, MEMORY_KINDS, MINUTE, NotFoundError, PERCEPTION_MODES, PLACEABLE_KINDS, PLOT_NUDGE_MODES, PLOT_STATUSES, RECALL_ITEM_KINDS, RoleplayState, LATEST_VERSION as SCHEMA_VERSION, SECOND, SESSION_DATABASE_FILE, SLOT_ID, SUMMARY_LEVELS, SchemaError, StateError, THREAD_STATUSES, TIME_CHANGE_KINDS, TRIGGER_NOTE_KINDS, TRIGGER_STATUSES, VARIABLE_KEY, VARIABLE_KINDS, VARIABLE_SUBJECTS, VARIABLE_VISIBILITIES, VISUAL_SUBJECT_KINDS, WEEKDAY_NAMES, addLocalDays, agendaAt, announcements, apply, applyItemPlan, applyRecordsEdit, audienceIds, catchUpPlan, changeItem, changeVariable, characterKey, clarityAt, clockTime, conditionHolds, createCharacterTools, createSession, createSessionStore, createTools, dayPart, deleteSession, denseScore, describeDuration, describeHolder, describeInstant, describeValue, finishRecall, fuseScores, inAudience, inWindow, isSessionId, isTimeZone, itemKey, jitter, judgedStatements, lapseNotes, lintWorld, listSessions, localIso, localTime, locationKey, mentioned, moveCharacter, name, nextOccurrence, nextTimeOfDay, nodeSqliteDriver, occurrenceAt, openSession, openSessionStore, overlap, parseInstant, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, retention, runTriggers, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemTimeZone, tokens, triggerReferenceProblems, valueIssue, zonedInstant };
+export { ACCURACIES, CHARACTER_CONTROLS, CHARACTER_KINDS, CHARACTER_ROLES, CHARACTER_TIERS, CLOCK_MODES, COMPARISONS, CONSOLIDATION_KINDS, CONTAINER_STATES, Config, ConflictError, CorruptDataError, DAY, DAY_PARTS, DEFAULT_MEMORY_POLICY, DEFAULT_SLOTS, EMOTION_VARIABLES, ENGAGEMENT_GRACE, ENGAGEMENT_STATUSES, EXIT_STATES, HOUR, IMPORTANCE_MAX, IMPORTANCE_MIN, INTENT_HORIZONS, INTENT_STATUSES, INTENT_TYPES, ITEM_ACTIONS, InvalidEditError, InvalidMoveError, InvalidValueError, KNOWLEDGE_KINDS, LORE_KINDS, LORE_SUBJECT_KINDS, MAX_LOCATION_FEATURES, MAX_ROUTINE_WINDOWS, MAX_SHOWN, MAX_TRIGGERS, MAX_VARIABLES, MEMBERSHIP_STATUSES, MEMORY_KINDS, MIGRATION_BACKUP_FOLDER, MINUTE, NotFoundError, PERCEPTION_MODES, PLACEABLE_KINDS, PLOT_NUDGE_MODES, PLOT_STATUSES, RECALL_ITEM_KINDS, RoleplayState, LATEST_VERSION as SCHEMA_VERSION, SECOND, SESSION_DATABASE_FILE, SLOT_ID, SUMMARY_LEVELS, SchemaError, StateError, THREAD_STATUSES, TIME_CHANGE_KINDS, TRIGGER_NOTE_KINDS, TRIGGER_STATUSES, VARIABLE_KEY, VARIABLE_KINDS, VARIABLE_SUBJECTS, VARIABLE_VISIBILITIES, VISUAL_SUBJECT_KINDS, WEEKDAY_NAMES, addLocalDays, agendaAt, announcements, apply, applyItemPlan, applyRecordsEdit, audienceIds, catchUpPlan, changeItem, changeVariable, characterKey, clarityAt, clockTime, conditionHolds, createCharacterTools, createSession, createSessionStore, createTools, dayPart, deleteSession, denseScore, describeDuration, describeHolder, describeInstant, describeValue, finishRecall, fuseScores, inAudience, inWindow, isSessionId, isTimeZone, itemKey, jitter, judgedStatements, lapseNotes, lintWorld, listSessions, localIso, localTime, locationKey, mentioned, migrationBackupPath, moveCharacter, name, nextOccurrence, nextTimeOfDay, nodeSqliteDriver, occurrenceAt, openSession, openSessionStore, overlap, parseInstant, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, retention, runTriggers, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemTimeZone, tokens, triggerReferenceProblems, valueIssue, zonedInstant };
 
 //# sourceMappingURL=index.js.map