@dsh-agentic-roleplay/state 0.2.1 → 0.3.1

package/lib/index.js

@@ -141,6 +141,15 @@ const MEMORY_KINDS = [
 	"relationship",
 	"knowledge"
 ];
+/** How sure a character is of what it believes, from least to most. */
+const MEMORY_CONFIDENCES = [
+	"doubtful",
+	"likely",
+	"sure"
+];
+const DEFAULT_CONFIDENCE = "likely";
+/** Whether a perception speaks for a belief or against it. */
+const EVIDENCE_RELATIONS = ["supports", "contradicts"];
 const THREAD_STATUSES = ["open", "resolved"];
 /** A digest covers a stretch of recent turns closely; a chapter covers older turns briefly. */
 const SUMMARY_LEVELS = ["digest", "chapter"];
@@ -346,6 +355,8 @@ const COMPARISONS = [
 	"gt",
 	"ge"
 ];
+/** In a cue, the key of the character it is said to: in a `while` condition and in the words of the cue. */
+const SELF = "@self";
 const TRIGGER_STATUSES = [
 	"dormant",
 	"fired",
@@ -401,6 +412,213 @@ const PLOT_NUDGE_MODES = [
 	"breathing_room"
 ];
 //#endregion
+//#region ../dsh-roleplay-model/src/messages-zh.ts
+/** The Chinese of the texts built in code, by the English that stands in the code. A `{name}` is filled in and must stand in both. */
+const ZH = {
+	", ": "，",
+	"; ": "；",
+	": ": "：",
+	".": "。",
+	" and ": "和",
+	"doubtful": "存疑",
+	"likely": "较有把握",
+	"sure": "确信",
+	"open": "畅通",
+	"locked": "已上锁",
+	"blocked": "被堵住",
+	"night": "夜里",
+	"morning": "上午",
+	"afternoon": "下午",
+	"evening": "傍晚",
+	"spring": "春季",
+	"summer": "夏季",
+	"autumn": "秋季",
+	"winter": "冬季",
+	"today is {holidays}": "今天是{holidays}",
+	"Summary": "概述",
+	"Personality": "性格",
+	"Background": "背景",
+	"Appearance": "外貌",
+	"How you speak": "说话方式",
+	"You are {name}.": "你是{name}。",
+	"You are also called {names}.": "你也被称作{names}。",
+	"age: {value}": "年龄：{value}",
+	"gender: {value}": "性别：{value}",
+	"pronouns: {value}": "代词：{value}",
+	"Situation:": "当前情形：",
+	"Now: {time}.": "现在是：{time}。",
+	"Where you are:": "你所在之处：",
+	"Present:": "在场的人：",
+	" (you)": "（你）",
+	"What you know is coming:": "你知道即将发生的事：",
+	"Just now you notice:": "此刻你注意到：",
+	"How you are (what you can tell of yourself):": "你的状态（你自己能感觉到的）：",
+	"What you can tell of the others here:": "你能看出在场其他人的情况：",
+	"What you have on you:": "你身上带着：",
+	"Things here: ": "这里有：",
+	"Ways out: ": "出路：",
+	"Lying about: ": "散落在周围的：",
+	"hidden": "隐蔽",
+	" holding {things}": "，里面有{things}",
+	"; and {count} more": "；另有{count}项",
+	"at {feature}": "在{feature}",
+	"; and {count} more you can recall if needed": "；另有{count}项，需要时你可以回想起来",
+	"What you know exists (this does not tell you where it is now or what state it is in):": "你知道存在的事物（这并不说明它现在在哪里、处于什么状态）：",
+	"People: ": "人物：",
+	"Factions: ": "组织：",
+	"Places: ": "地点：",
+	"Routes: ": "路径：",
+	"Things: ": "物品：",
+	"Your day and what you are after (plans, not orders: keep them, put them off or drop them as the moment and your character suggest):": "你的日程与你想达成的事（只是计划，不是命令：依当下情形和你的性格，可以照做、推迟或放弃）：",
+	"Your day, now: {activity}{place}, until {until}{note}.": "你此刻的日程：{activity}{place}，持续到{until}{note}。",
+	"Your day, next: {activity}{place}, from {from}.": "你接下来的日程：{activity}{place}，{from}开始。",
+	" at {place}": "，在{place}",
+	" (not something you would drop lightly)": "（你不会轻易放下）",
+	", with {names}": "，与{names}一起",
+	"You were to: {title}{place}{with}, at {at}, which has passed and is still open.": "你本应：{title}{place}{with}，时间是{at}，已经过了，事情仍未了结。",
+	"You are due to: {title}{place}{with}, at {at}.": "你约定要：{title}{place}{with}，时间是{at}。",
+	"What you are after:": "你想达成的事：",
+	", by {deadline}, which has passed": "，限期{deadline}，已过",
+	", by {deadline}": "，限期{deadline}",
+	" Next: {plan}.": " 下一步：{plan}。",
+	"How you stand with people who bear on this moment (your own view, not objective fact):": "你与和此刻相关的人的关系（是你自己的看法，不是客观事实）：",
+	" (here)": "（在场）",
+	" (not here)": "（不在场）",
+	"knows them well": "很了解对方",
+	"barely knows them": "几乎不了解对方",
+	"trusts them": "信任对方",
+	"distrusts them": "不信任对方",
+	"is fond of them": "喜欢对方",
+	"dislikes them": "不喜欢对方",
+	"things are strained between them": "彼此关系紧张",
+	"Your affiliations (their goals are pressures and commitments, not commands):": "你的所属组织（其目标是压力和承诺，不是命令）：",
+	"member": "成员",
+	" Goals: {goals}.": " 目标：{goals}。",
+	"- {name}: {position}; {status}; commitment {commitment}.": "- {name}：{position}；{status}；投入程度 {commitment}。",
+	" Your view: {attitude}.": " 你的看法：{attitude}。",
+	"What you remember that bears on this (only what you took in yourself; do not claim to remember more, and be unsure of what is fuzzy):": "你记得的、与此相关的事（只限你自己亲身经历的；不要声称记得更多，模糊的地方要保持不确定）：",
+	"What you remember that bears on this: nothing comes to mind.": "你记得的、与此相关的事：想不起任何事。",
+	"some time ago": "一段时间以前",
+	"just now": "刚才",
+	"1 day ago": "1天前",
+	"{amount} days ago": "{amount}天前",
+	"1 hour ago": "1小时前",
+	"{amount} hours ago": "{amount}小时前",
+	"1 minute ago": "1分钟前",
+	"{amount} minutes ago": "{amount}分钟前",
+	"the details are fuzzy": "细节已经模糊",
+	"you barely remember": "你几乎记不清了",
+	"you are sure of it": "你对此确信无疑",
+	"you doubt it": "你对此存疑",
+	"something you have seen since speaks against it": "此后你所见所闻有与之相悖的地方",
+	"it comes to mind with the rest": "它和其余的事一起浮现在脑海",
+	"Earlier in this scene, before this moment:": "这一幕此刻之前发生的事：",
+	"What just happened, and what you are reacting to:": "刚才发生的事，以及你在回应的是什么：",
+	"- {name} intended: {intent} ({result}) {summary}": "- {name}打算：{intent}（{result}）{summary}",
+	"- {name} said \"{utterance}\" and intended: {intent} ({result}) {summary}": "- {name}说了“{utterance}”，并打算：{intent}（{result}）{summary}",
+	"Your earlier intent did not work out: {intent}\nYou are trying again, knowing the above. Decide again what you do now.": "你先前的打算没有成功：{intent}\n你带着上面这些再试一次。重新决定你现在做什么。",
+	"Character: {name}{summary}": "角色：{name}{summary}",
+	"What they believe now:": "他们现在的看法：",
+	"(nothing yet)": "（暂时没有）",
+	"What they have taken in since:": "他们此后经历的事：",
+	"Sort their memory.": "请整理他们的记忆。",
+	"not acceptable: {problems}": "不可接受：{problems}",
+	"{kind}, importance {importance}, {confidence}{about}{dispute}": "{kind}，重要性 {importance}，{confidence}{about}{dispute}",
+	", about {names}": "，关于{names}",
+	", something taken in since speaks against it": "，此后经历的事与之相悖",
+	"add: at most {max} new beliefs in one pass; merge or choose": "add：一次最多 {max} 条新看法；请合并或取舍",
+	"at most {max} changes in one pass": "一次最多 {max} 处修改",
+	"{where}: there is no thing it took in numbered {id}": "{where}：没有编号为 {id} 的经历",
+	"{where}: confidence is one of {options}": "{where}：confidence 须为 {options} 之一",
+	"{where}: unknown kind \"{kind}\"": "{where}：未知的 kind “{kind}”",
+	"{where}: say what it believes": "{where}：请写出它相信什么",
+	"{where}: at most {max} characters; say it shorter": "{where}：最多 {max} 个字符；请写得更短",
+	"{where}: importance runs from {min} to {max}": "{where}：importance 取值为 {min} 到 {max}",
+	"{where}: there is no belief numbered {id}": "{where}：没有编号为 {id} 的看法",
+	"{where}: one passing moment is not yet a belief; rest it on things from at least two different turns, or on one event that turned the story": "{where}：一个转瞬即逝的瞬间还不是看法；请以至少两个不同回合的经历为依据，或以一件扭转了故事的事件为依据",
+	"{where}: to be sure of something it must rest on things from at least two different turns": "{where}：要对某事确信，必须以至少两个不同回合的经历为依据",
+	"{where}: \"{name}\" is not a character; name them as they are named": "{where}：“{name}”不是角色；请使用他们的名字",
+	"{where}: belief {id} is already changed in this pass": "{where}：看法 {id} 在这一轮中已经修改过",
+	"{where}: say what it took in since that bears on it": "{where}：请写出此后与之相关的经历",
+	"{where}: thing {id} came before the belief was formed; cite what came after": "{where}：经历 {id} 发生在看法形成之前；请引用之后发生的事",
+	"{where}: say what changes": "{where}：请写出有何改变",
+	"{where}: the text must be there and at most {max} characters": "{where}：必须有文字，且最多 {max} 个字符",
+	"{where}: a belief that something contradicts must be doubted: lower its confidence": "{where}：被事实相悖的看法必须存疑：请降低其 confidence",
+	"{where}: to doubt a belief, name what contradicts it in contradicted_by": "{where}：要对看法存疑，请在 contradicted_by 中写明与之相悖的经历",
+	"{where}: merge into a belief that stays": "{where}：请合并到保留的看法中",
+	"Time: {time}.": "时间：{time}。",
+	"The story's time moves only as you say: each round takes what you give it (elapsed_seconds in resolve_round, or the default), and advance_time skips ahead.": "故事的时间只按你说的推进：每一轮耗时由你给定（resolve_round 的 elapsed_seconds，或取默认值），advance_time 可以跳过一段时间。",
+	"The player was away for {duration} of real time and the story went on meanwhile: characters have been about their own business, so do not assume anyone is where or as the player left them unless the records say so.": "玩家离开了{duration}的真实时间，其间故事仍在继续：角色们各忙各的事，除非记录另有说明，不要假定任何人还在玩家离开时的位置或状态。",
+	"The story's time follows the real clock: it cannot be skipped, and each round takes as long as it really took.": "故事时间跟随真实时钟：无法跳过，每一轮耗时就是它实际花费的时间。",
+	"By their routines since you last looked: {moves}.": "按各自的日程，自你上次查看以来：{moves}。",
+	"{name} went to {place} ({activity})": "{name}去了{place}（{activity}）",
+	"With the player's character, and their days: {days}. The characters decide for themselves whether to keep to their day; the moment may keep them.": "与玩家角色在一起的人及其日程：{days}。是否照日程行事由角色自己决定；当下的情形也可能拖住他们。",
+	", at {place}": "，在{place}",
+	"\"{title}\" ({with}{place}) was due {when} and is still open": "“{title}”（{with}{place}）原定{when}，仍未了结",
+	"\"{title}\" ({with}{place}) is due {when}": "“{title}”（{with}{place}）定于{when}",
+	"Commitments due soon or overdue: {entries}.": "即将到期或已逾期的约定：{entries}。",
+	"named in the move": "被这一步行动点到",
+	"in the scene": "在场",
+	"own goal: {goal}": "自身目标：{goal}",
+	"faction pressure: {goal}": "组织压力：{goal}",
+	"high tension toward the player": "对玩家高度紧张",
+	"distrusts the player": "不信任玩家",
+	"cares about the player": "在意玩家",
+	"dislikes the player": "不喜欢玩家",
+	"Likely characters to activate, in priority order (advice only; activate only whoever the moment actually reaches):": "可能需要启动的角色，按优先级排列（仅供参考；只启动当下真正牵涉到的人）：",
+	"socially implicated": "社交上被牵涉",
+	"The player's character is in {place}": "玩家角色在{place}",
+	"Characters here:": "在这里的角色：",
+	"Characters elsewhere (they perceive nothing here unless the moment reaches them):": "在别处的角色（除非当下波及他们，否则感知不到这里的事）：",
+	"{member} - in {place} ({key})": "{member} - 在{place}（{key}）",
+	"Characters with no place (not part of this scene; they cannot be asked to act):": "没有所在地点的角色（不属于这一幕；不能让他们行动）：",
+	"the player's character, \"{key}\"": "玩家角色，“{key}”",
+	"acts through \"{key}\"": "通过“{key}”行动",
+	"Currently: {state}": "目前：{state}",
+	"Scene before turn {turn}:": "第 {turn} 回合之前的场景：",
+	"What characters have on them:": "角色们身上带着：",
+	"The world acted since the last turn, by itself:": "自上一回合以来，世界自行发生的事：",
+	"Known beforehand, still to come (who knows of it; it will happen by itself when its time comes):": "事先已知、尚未发生的事（谁知道；时候到了会自行发生）：",
+	"[known to {who}]": "[知情者：{who}]",
+	"Weave these into the story when it fits, then say you did with addressed in narrate (each stays for a few turns and is then let go):": "合适时把这些织入故事，然后在 narrate 的 addressed 中说明已处理（每条会保留几个回合，之后放弃）：",
+	"What the story keeps track of (change it with variable_changes in an outcome when what happened calls for it):": "故事追踪的内容（发生的事需要时，在结果中用 variable_changes 修改）：",
+	"Still open in the story:": "故事中仍未了结的事：",
+	"Earlier events that bear on what the player just did (from the records of the story):": "与玩家刚才的行动相关的早先事件（来自故事记录）：",
+	"turn {turn}": "第 {turn} 回合",
+	"You were to {title}, at {when}": "你本应{title}，时间是{when}",
+	"You were to {title} at {place}, at {when}": "你本应在{place}：{title}，时间是{when}",
+	" ({note})": "（{note}）",
+	"It is {now} now and the time has passed.": "现在是{now}，时间已经过了。",
+	"It is {now} now.": "现在是{now}。",
+	"It was with: {who}.": "同你一起的有：{who}。",
+	"You are not with the player's character, and nothing of this happens in front of anyone: decide what you do about it.": "你不和玩家的角色在一起，这件事也不会发生在任何人面前：决定你要怎么处理。",
+	"The time you had for \"{goal}\" has passed ({when}; it is {now} now)": "你为“{goal}”预留的时间已过（{when}；现在是{now}）",
+	"You are not with the player's character and nothing of this happens in front of anyone: decide what you do about it.": "你不和玩家的角色在一起，这件事也不会发生在任何人面前：决定你要怎么处理。",
+	"{names} noticed: {text}": "{names}注意到：{text}",
+	"{name} went to {place}.": "{name}去了{place}。"
+};
+//#endregion
+//#region ../dsh-roleplay-model/src/messages.ts
+/** The languages the texts a model reads are written in. English is the source: a text is its own key. */
+const LANGUAGES = ["en", "zh"];
+/** The language a setting such as `zh-CN` or `en` stands for; English when it is none that is known. */
+function languageOf(code) {
+	return (code ?? "").trim().toLowerCase().startsWith("zh") ? "zh" : "en";
+}
+const fill = (template, values) => values === void 0 ? template : template.replace(/\{(\w+)\}/g, (whole, name) => name in values ? String(values[name]) : whole);
+const CATALOGUES = { zh: ZH };
+/**
+* The texts the engine builds for a model (briefs, reports, refusals) in a language. The text written in the code is the English one and the key of
+* the others; a text a language lacks is told in English, and a test keeps that from happening.
+*/
+function translator(language) {
+	const catalogue = language === "en" ? void 0 : CATALOGUES[language];
+	return (text, values) => fill(catalogue?.[text] ?? text, values);
+}
+/** The texts with a translation, for the test that every text has one. */
+const translated = (language) => Object.keys(CATALOGUES[language]);
+const translation = (language, text) => CATALOGUES[language][text];
+//#endregion
 //#region src/clock.ts
 const systemClock = () => /* @__PURE__ */ new Date();
 //#endregion
@@ -560,6 +778,7 @@ const toWindow = (row) => ({
 	id: row.id,
 	characterId: row.character_id,
 	days: parseNumberList(row.days, "routine_windows.days"),
+	on: parseStringList(row.filters, "routine_windows.filters"),
 	start: row.start_minute,
 	end: row.end_minute,
 	activity: row.activity,
@@ -593,10 +812,11 @@ var SqliteRoutineRepository = class {
 			if (this.db.get("SELECT 1 FROM characters WHERE id = ?", [characterId]) === void 0) throw new NotFoundError(`character ${characterId} does not exist`);
 			this.db.run("DELETE FROM routine_windows WHERE character_id = ?", [characterId]);
 			windows.forEach((window, index) => {
-				this.db.run("INSERT INTO routine_windows (character_id, ordinal, days, start_minute, end_minute, activity, location_id, feature_key, position, interruptible) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
+				this.db.run("INSERT INTO routine_windows (character_id, ordinal, days, filters, start_minute, end_minute, activity, location_id, feature_key, position, interruptible) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
 					characterId,
 					index,
 					toJson([...new Set(window.days)].sort()),
+					toJson([...new Set(window.on ?? [])]),
 					window.start,
 					window.end,
 					window.activity.trim(),
@@ -705,6 +925,226 @@ var SqliteEngagementRepository = class {
 	}
 };
 //#endregion
+//#region src/records/calendar.ts
+/**
+* Which days a thing applies on, beyond the days of the week: whole months, a date every year or once, a stretch of dates, the day of the month,
+* the first or last Monday of a month, a season, and the holidays a world names. A day is told by tokens (`dec`, `12-24`, `1912-09-21..1912-09-22`,
+* `dom:1`, `nth:mon:1`, `season:winter`, `holiday:founders-day`, `fri`); a token with `!` before it is a day it does not apply on. A list holds on a
+* day when it names no day to apply on or one of them is today, and none of the days to leave out is.
+*/
+const MONTH_NAMES = [
+	"jan",
+	"feb",
+	"mar",
+	"apr",
+	"may",
+	"jun",
+	"jul",
+	"aug",
+	"sep",
+	"oct",
+	"nov",
+	"dec"
+];
+const SEASONS = [
+	"spring",
+	"summer",
+	"autumn",
+	"winter"
+];
+const NO_CALENDAR = {
+	hemisphere: "north",
+	holidays: []
+};
+const MAX_TOKEN = 60;
+const daysIn = (year, month) => new Date(Date.UTC(year, month, 0)).getUTCDate();
+const DATE = /^(?:(\d{4})-)?(\d{2})-(\d{2})$/;
+function dateOf(text) {
+	const found = DATE.exec(text);
+	if (found === null) return void 0;
+	const [, year, month, day] = found;
+	const m = Number(month);
+	const d = Number(day);
+	if (m < 1 || m > 12 || d < 1 || d > daysIn(year === void 0 ? 2024 : Number(year), m)) return void 0;
+	return {
+		...year === void 0 ? {} : { year: Number(year) },
+		month: m,
+		day: d
+	};
+}
+/** What a token says, or why it says nothing. */
+function parseDayToken(raw) {
+	const negated = raw.startsWith("!");
+	const text = (negated ? raw.slice(1) : raw).trim().toLowerCase();
+	const fail = (problem) => ({ problem: `"${raw}": ${problem}` });
+	if (text === "" || text.length > MAX_TOKEN) return fail("a day is told in a few words");
+	const weekday = WEEKDAY_NAMES.indexOf(text);
+	if (weekday >= 0) return {
+		token: {
+			kind: "weekday",
+			weekday
+		},
+		negated
+	};
+	const month = MONTH_NAMES.indexOf(text);
+	if (month >= 0) return {
+		token: {
+			kind: "month",
+			month: month + 1
+		},
+		negated
+	};
+	const one = dateOf(text);
+	if (one !== void 0) return {
+		token: {
+			kind: "date",
+			...one
+		},
+		negated
+	};
+	if (text.includes("..")) {
+		const [from, to, ...rest] = text.split("..");
+		const start = from === void 0 ? void 0 : dateOf(from);
+		const end = to === void 0 ? void 0 : dateOf(to);
+		if (rest.length > 0 || start === void 0 || end === void 0 || start.year === void 0 !== (end.year === void 0)) return fail("a stretch is two dates of the same kind: `12-20..01-05` every year, or `1912-09-21..1912-09-22` once");
+		return {
+			token: {
+				kind: "span",
+				from: start,
+				to: end
+			},
+			negated
+		};
+	}
+	const [head, a, b] = text.split(":");
+	if (head === "dom" && a !== void 0 && b === void 0) {
+		if (a === "last") return {
+			token: {
+				kind: "dom",
+				day: "last"
+			},
+			negated
+		};
+		const day = Number(a);
+		return Number.isInteger(day) && day >= 1 && day <= 31 ? {
+			token: {
+				kind: "dom",
+				day
+			},
+			negated
+		} : fail("the day of the month is 1 to 31, or `dom:last`");
+	}
+	if (head === "nth" && a !== void 0 && b !== void 0) {
+		const day = WEEKDAY_NAMES.indexOf(a);
+		const n = b === "last" ? "last" : Number(b);
+		return day >= 0 && (n === "last" || Number.isInteger(n) && n >= 1 && n <= 5) ? {
+			token: {
+				kind: "nth",
+				weekday: day,
+				n
+			},
+			negated
+		} : fail("`nth:mon:1` is the first Monday of a month, `nth:fri:last` the last Friday");
+	}
+	if (head === "season" && a !== void 0 && b === void 0) {
+		const season = SEASONS.find((candidate) => candidate === a);
+		return season === void 0 ? fail(`a season is one of ${SEASONS.join(", ")}`) : {
+			token: {
+				kind: "season",
+				season
+			},
+			negated
+		};
+	}
+	if (head === "holiday" && a !== void 0 && b === void 0 && a !== "") return {
+		token: {
+			kind: "holiday",
+			id: a
+		},
+		negated
+	};
+	return fail("not a day: use a weekday (`mon`), a month (`dec`), a date (`12-24`, `1912-09-21`), a stretch (`12-20..01-05`), `dom:1`, `nth:mon:1`, `season:winter` or `holiday:<id>`");
+}
+/** What is wrong with a list of day tokens, each with where it is. `holidays` are those the world names, when `holiday:` may be used. */
+function dayTokenProblems(tokens, path, holidays) {
+	return tokens.flatMap((raw) => {
+		const parsed = parseDayToken(raw);
+		if ("problem" in parsed) return [`${path}: ${parsed.problem}`];
+		if (parsed.token.kind === "holiday") {
+			if (holidays === void 0) return [`${path}: "${raw}": a holiday cannot be named here`];
+			if (holidays !== "any" && !holidays.has(parsed.token.id)) return [`${path}: "${raw}": the world names no holiday "${parsed.token.id}"`];
+		}
+		return [];
+	});
+}
+/** The season a day is in, by the months of its hemisphere (winter is December to February in the north, June to August in the south). */
+function seasonOf(day, hemisphere = "north") {
+	const north = day.month === 12 || day.month <= 2 ? "winter" : day.month <= 5 ? "spring" : day.month <= 8 ? "summer" : "autumn";
+	if (hemisphere === "north") return north;
+	return north === "winter" ? "summer" : north === "summer" ? "winter" : north === "spring" ? "autumn" : "spring";
+}
+const key = (month, day) => month * 100 + day;
+function within(day, from, to) {
+	if (from.year !== void 0 && to.year !== void 0) {
+		const at = day.year * 1e4 + key(day.month, day.day);
+		return at >= from.year * 1e4 + key(from.month, from.day) && at <= to.year * 1e4 + key(to.month, to.day);
+	}
+	const at = key(day.month, day.day);
+	const start = key(from.month, from.day);
+	const end = key(to.month, to.day);
+	return start <= end ? at >= start && at <= end : at >= start || at <= end;
+}
+function matches(token, day, calendar) {
+	switch (token.kind) {
+		case "weekday": return day.weekday === token.weekday;
+		case "month": return day.month === token.month;
+		case "date": return day.month === token.month && day.day === token.day && (token.year === void 0 || day.year === token.year);
+		case "span": return within(day, token.from, token.to);
+		case "dom": return token.day === "last" ? day.day === daysIn(day.year, day.month) : day.day === token.day;
+		case "nth": return day.weekday === token.weekday && (token.n === "last" ? day.day + 7 > daysIn(day.year, day.month) : Math.ceil(day.day / 7) === token.n);
+		case "season": return seasonOf(day, calendar.hemisphere) === token.season;
+		case "holiday": return holidaysOn(calendar, day).some((holiday) => holiday.id === token.id);
+	}
+}
+/** Whether a list of day tokens holds on a day; tokens that say nothing sensible count as not matching. An empty list holds on every day. */
+function dayMatches(tokens, day, calendar = NO_CALENDAR) {
+	const parsed = tokens.flatMap((raw) => {
+		const found = parseDayToken(raw);
+		return "problem" in found ? [] : [found];
+	});
+	const wanted = parsed.filter((entry) => !entry.negated);
+	const unwanted = parsed.filter((entry) => entry.negated);
+	return (wanted.length === 0 || wanted.some((entry) => matches(entry.token, day, calendar))) && !unwanted.some((entry) => matches(entry.token, day, calendar));
+}
+/** The holidays that fall on a day. A holiday is told by days that are no holidays themselves, so that none can lead back to itself. */
+function holidaysOn(calendar, day) {
+	return calendar.holidays.filter((holiday) => holiday.on.length > 0 && dayMatches(holiday.on, day, {
+		...calendar,
+		holidays: []
+	}));
+}
+const CALENDAR_KEY = "calendar";
+/** The calendar a story was started with, from its metadata; none when the world has none. */
+function readCalendar(metadata) {
+	const stored = metadata.getValue(CALENDAR_KEY);
+	if (typeof stored !== "object" || stored === null || Array.isArray(stored)) return NO_CALENDAR;
+	const { hemisphere, holidays } = stored;
+	return {
+		hemisphere: hemisphere === "south" ? "south" : "north",
+		holidays: Array.isArray(holidays) ? holidays.flatMap((entry) => {
+			const { id, name, on } = entry ?? {};
+			return typeof id === "string" && typeof name === "string" && Array.isArray(on) ? [{
+				id,
+				name,
+				on: on.filter((token) => typeof token === "string")
+			}] : [];
+		}) : []
+	};
+}
+const writeCalendar = (metadata, calendar) => {
+	metadata.setValue(CALENDAR_KEY, calendar);
+};
+//#endregion
 //#region src/records/time.ts
 /** Instants are UTC milliseconds; a time zone only decides how they read. */
 const SECOND = 1e3;
@@ -832,17 +1272,27 @@ function parseInstant(text, zone) {
 	}
 	throw new RangeError(`"${text}" is not a date and time: write it as 1912-10-04T19:30 (or with an offset, 1912-10-04T19:30+01:00)`);
 }
-/** `Tuesday 4 October 1912, 21:40`. */
-function describeInstant(instant, zone) {
+const WEEKDAYS_ZH = [
+	"星期日",
+	"星期一",
+	"星期二",
+	"星期三",
+	"星期四",
+	"星期五",
+	"星期六"
+];
+/** `Tuesday 4 October 1912, 21:40`, or `1912年10月4日 星期二 21:40`. */
+function describeInstant(instant, zone, language = "en") {
 	const local = localTime(instant, zone);
-	return `${WEEKDAYS[local.weekday]} ${local.day} ${MONTHS[local.month - 1]} ${local.year}, ${pad(local.hour)}:${pad(local.minute)}`;
+	if (language === "zh") return `${local.year}年${local.month}月${local.day}日 ${WEEKDAYS_ZH[local.weekday]} ${pad$1(local.hour)}:${pad$1(local.minute)}`;
+	return `${WEEKDAYS[local.weekday]} ${local.day} ${MONTHS[local.month - 1]} ${local.year}, ${pad$1(local.hour)}:${pad$1(local.minute)}`;
 }
 /** `1912-10-04T21:40:00` as the wall clock of a zone reads, the form a file or a person can write back. */
 function localIso(instant, zone) {
 	const local = localTime(instant, zone);
-	return `${String(local.year).padStart(4, "0")}-${pad(local.month)}-${pad(local.day)}T${pad(local.hour)}:${pad(local.minute)}:${pad(local.second)}`;
+	return `${String(local.year).padStart(4, "0")}-${pad$1(local.month)}-${pad$1(local.day)}T${pad$1(local.hour)}:${pad$1(local.minute)}:${pad$1(local.second)}`;
 }
-const pad = (value) => String(value).padStart(2, "0");
+const pad$1 = (value) => String(value).padStart(2, "0");
 const DAY_PARTS = [
 	"night",
 	"morning",
@@ -854,9 +1304,25 @@ function dayPart(minuteOfDay) {
 	const hour = Math.floor(minuteOfDay / 60);
 	return hour < 5 || hour >= 22 ? "night" : hour < 12 ? "morning" : hour < 17 ? "afternoon" : "evening";
 }
-/** In words and rounded to what matters: `45 seconds`, `3 hours 12 minutes`, `2 days 3 hours`. */
-function describeDuration(milliseconds) {
+/** In words and rounded to what matters: `45 seconds`, `3 hours 12 minutes`, `2 days 3 hours`; or `45秒`, `3小时12分钟`, `2天3小时`. */
+function describeDuration(milliseconds, language = "en") {
 	const total = Math.max(0, Math.round(milliseconds / SECOND));
+	if (language === "zh") {
+		if (total < 60) return `${total}秒`;
+		const parts = [];
+		let left = total;
+		for (const [name, size] of [
+			["天", 86400],
+			["小时", 3600],
+			["分钟", 60]
+		]) {
+			const count = Math.floor(left / size);
+			left -= count * size;
+			if (count > 0) parts.push(`${count}${name}`);
+			if (parts.length === 2) break;
+		}
+		return parts.join("");
+	}
 	if (total < 60) return `${total} second${total === 1 ? "" : "s"}`;
 	const units = [
 		["day", 86400],
@@ -946,7 +1412,7 @@ function catchUpPlan(cursor, now, limits = {}) {
 /** `21:40`: the clock of a zone at an instant. */
 function clockTime(instant, zone) {
 	const local = localTime(instant, zone);
-	return `${pad(local.hour)}:${pad(local.minute)}`;
+	return `${pad$1(local.hour)}:${pad$1(local.minute)}`;
 }
 /** The local calendar day `days` after the one the instant falls on, as year, month and day. */
 function addLocalDays(instant, zone, days) {
@@ -964,7 +1430,7 @@ function addLocalDays(instant, zone, days) {
 	};
 }
 /** `07:30` for a minute of the day. */
-const minuteText = (minute) => `${pad(Math.floor(minute / 60))}:${pad(minute % 60)}`;
+const minuteText = (minute) => `${pad$1(Math.floor(minute / 60))}:${pad$1(minute % 60)}`;
 //#endregion
 //#region src/records/agenda-edit.ts
 const MAX_PLAN_STEPS = 8;
@@ -1112,6 +1578,8 @@ function prepareAgenda(target, edit, context) {
 					if (found < 0) problems.push(`${here}.days: "${day}" is not a day (${WEEKDAY_NAMES.join(", ")})`);
 					return found < 0 ? [] : [found];
 				});
+				const holidays = new Set(readCalendar(target.metadata).holidays.map((holiday) => holiday.id));
+				problems.push(...dayTokenProblems(list$1(window.on), `${here}.on`, holidays));
 				if (window.location !== void 0) {
 					placeKnown(window.location, `${here}.location`);
 					const place = context.places.get(window.location);
@@ -1120,6 +1588,7 @@ function prepareAgenda(target, edit, context) {
 				if (start === void 0 || end === void 0) return [];
 				return [{
 					days,
+					on: [...list$1(window.on)],
 					start,
 					end,
 					activity: window.activity.trim(),
@@ -1664,6 +2133,78 @@ function moveCharacter(context, characterId, move) {
 	return result.plan;
 }
 //#endregion
+//#region src/records/template.ts
+/**
+* What the words of a cue or a beat may name by `{kind:key}`, filled in from the story when they are told. The key is how the world's files
+* name the thing (`@self` in a cue is the character it is said to), and a name follows the story: a renamed character is renamed in the words.
+*/
+const TEMPLATE_KINDS = {
+	/** The name of a character. */
+	character: {
+		args: 1,
+		about: "a character"
+	},
+	/** The name of a place. */
+	place: {
+		args: 1,
+		about: "a place"
+	},
+	/** The name of an item. */
+	item: {
+		args: 1,
+		about: "an item"
+	},
+	/** The name of the place a character is in now. */
+	where: {
+		args: 1,
+		about: "a character"
+	},
+	/** Who holds an item now, or the place it lies in. */
+	holder: {
+		args: 1,
+		about: "an item"
+	},
+	/** What a variable is now, in words: `{value:key}` for a world variable, `{value:key:subject}` for the character, item or place it is about. */
+	value: {
+		args: 2,
+		about: "a variable"
+	},
+	/** The time of day in the story, as `19:30`. */
+	time: {
+		args: 0,
+		about: ""
+	}
+};
+const PATTERN = /\{([a-z]+)(?::([^{}]*))?\}/g;
+/** The placeholders in some words, and what is wrong with any that is not one. Anything that does not look like `{word}` or `{word:key}` is plain text. */
+function placeholdersOf(text) {
+	const found = [];
+	const problems = [];
+	for (const match of text.matchAll(PATTERN)) {
+		const [raw, word, rest] = match;
+		if (!(word in TEMPLATE_KINDS)) {
+			problems.push(`${raw}: there is no "${word}"; the words may name ${Object.keys(TEMPLATE_KINDS).join(", ")}`);
+			continue;
+		}
+		const kind = word;
+		const args = rest === void 0 ? [] : rest.split(":").map((part) => part.trim());
+		const { args: wanted } = TEMPLATE_KINDS[kind];
+		if (!(kind === "value" ? args.length >= 1 && args.length <= 2 : args.length === wanted) || args.some((part) => part === "")) {
+			problems.push(`${raw}: ${kind === "time" ? "{time} takes nothing" : kind === "value" ? "{value:variable} or {value:variable:subject}" : `{${kind}:key} takes the key of ${TEMPLATE_KINDS[kind].about}`}`);
+			continue;
+		}
+		found.push({
+			raw,
+			kind,
+			args
+		});
+	}
+	return {
+		found,
+		problems
+	};
+}
+//#endregion
 //#region src/sqlite/variable-repository.ts
 const MAX_BANDS = 8;
 const MAX_OPTIONS = 12;
@@ -2069,8 +2610,11 @@ function parseCondition(value, path, problems, count, depth = 0) {
 				to: text(value["window"], "to") ?? ""
 			} : void 0;
 			const days = Array.isArray(value["days"]) ? value["days"].filter((day) => typeof day === "string") : void 0;
-			if (from === void 0 && to === void 0 && window === void 0 && days === void 0) {
-				problems.push(`${path}: a time condition needs from, to, window or days`);
+			const on = Array.isArray(value["on"]) ? value["on"].filter((day) => typeof day === "string") : void 0;
+			if (value["on"] !== void 0 && on?.length !== value["on"]?.length) problems.push(`${path}.on: a list of days (months, dates, seasons, holidays)`);
+			if (on !== void 0) problems.push(...dayTokenProblems(on, `${path}.on`, "any"));
+			if (from === void 0 && to === void 0 && window === void 0 && days === void 0 && on === void 0) {
+				problems.push(`${path}: a time condition needs from, to, window, days or on`);
 				return;
 			}
 			if (window !== void 0 && (parseTimeOfDay(window.from) === void 0 || parseTimeOfDay(window.to) === void 0 || window.from === window.to)) problems.push(`${path}.window: from and to are different times of day, HH:MM`);
@@ -2081,7 +2625,8 @@ function parseCondition(value, path, problems, count, depth = 0) {
 				...from === void 0 ? {} : { from },
 				...to === void 0 ? {} : { to },
 				...window === void 0 ? {} : { window },
-				...days === void 0 ? {} : { days }
+				...days === void 0 ? {} : { days },
+				...on === void 0 ? {} : { on }
 			};
 		}
 		case "place": {
@@ -2206,6 +2751,21 @@ function parseAnnouncement(value, path, problems) {
 		...at === void 0 ? {} : { at }
 	};
 }
+/** Whether words or a condition name the character a cue is said to. */
+function usesSelf(words, condition) {
+	return placeholdersOf(words).found.some((placeholder) => placeholder.args.includes("@self")) || condition !== void 0 && mentionsSelf(condition);
+}
+function mentionsSelf(condition) {
+	switch (condition.type) {
+		case "place": return condition.character === SELF;
+		case "variable": return condition.subject === SELF;
+		case "item": return condition.item === "@self" || condition.heldBy === "@self";
+		case "all":
+		case "any": return condition.conditions.some(mentionsSelf);
+		case "not": return mentionsSelf(condition.condition);
+		default: return false;
+	}
+}
 function parseEffect(value, path, problems, checkEdit) {
 	if (!isObject$2(value)) {
 		problems.push(`${path}: an effect is an object`);
@@ -2225,6 +2785,10 @@ function parseEffect(value, path, problems, checkEdit) {
 			problems.push(`${path}.edit: ${error instanceof InvalidEditError ? error.problems.join("; ") : String(error)}`);
 			return;
 		}
+		if (value["while"] !== void 0) {
+			problems.push(`${path}.while: only a beat or a cue can wait on a condition when it is told`);
+			return;
+		}
 		return {
 			type: "edit",
 			edit: value["edit"]
@@ -2239,16 +2803,26 @@ function parseEffect(value, path, problems, checkEdit) {
 		problems.push(`${path}.text: required text of at most ${MAX_TEXT$1} characters`);
 		return;
 	}
-	if (value["type"] === "beat") return {
-		type: "beat",
-		text: words
-	};
+	const template = placeholdersOf(words);
+	for (const problem of template.problems) problems.push(`${path}.text: ${problem}`);
+	const waiting = value["while"] === void 0 ? void 0 : parseCondition(value["while"], `${path}.while`, problems, { nodes: 0 });
+	if (value["while"] !== void 0 && waiting === void 0) return void 0;
+	if (waiting !== void 0 && judgedStatements(waiting).length > 0) problems.push(`${path}.while: a statement a model judges (judged) cannot be waited on when something is told; use what the story records`);
+	if (value["type"] === "beat") {
+		if (usesSelf(words, waiting)) problems.push(`${path}: only a cue is said to someone, so only a cue can name ${SELF}`);
+		return template.problems.length > 0 ? void 0 : {
+			type: "beat",
+			text: words,
+			...waiting === void 0 ? {} : { while: waiting }
+		};
+	}
 	if (value["type"] === "cue") {
 		const audience = value["audience"] !== void 0 ? parseAudience(value["audience"], `${path}.audience`, problems) : parseAudience({ characters: value["characters"] }, `${path}.characters`, problems);
-		return audience === void 0 ? void 0 : {
+		return audience === void 0 || template.problems.length > 0 ? void 0 : {
 			type: "cue",
 			audience,
-			text: words
+			text: words,
+			...waiting === void 0 ? {} : { while: waiting }
 		};
 	}
 	problems.push(`${path}.type: one of edit, beat, cue`);
@@ -2300,21 +2874,21 @@ function parseTriggerDefinition(value, path, checkEdit) {
 		...announce === void 0 ? {} : { announce }
 	} };
 }
-function conditionProblems(target, condition, path, known) {
-	const character = (key) => target.characters.list().some((entry) => characterKey(entry) === key) ? [] : [`${path}: there is no character "${key}"`];
+function conditionProblems(target, condition, path, known, self = false) {
+	const character = (key) => self && key === "@self" || target.characters.list().some((entry) => characterKey(entry) === key) ? [] : [`${path}: there is no character "${key}"`];
 	const place = (key) => target.locations.list().some((entry) => locationKey(entry) === key) ? [] : [`${path}: there is no place "${key}"`];
 	switch (condition.type) {
-		case "time": return [];
+		case "time": return dayTokenProblems(condition.on ?? [], `${path}.on`, new Set(readCalendar(target.metadata).holidays.map((holiday) => holiday.id)));
 		case "place": return [...character(condition.character), ...place(condition.location)];
 		case "variable": {
 			const def = target.variables.def(condition.variable);
 			if (def === void 0) return [`${path}: there is no variable "${condition.variable}"`];
 			if (def.subject === "world" ? condition.subject !== void 0 : condition.subject === void 0) return [`${path}: ${def.subject === "world" ? "a world variable has no subject" : `give the ${def.subject} it is about as subject`}`];
-			const subject = condition.subject === void 0 ? void 0 : subjectOf(target, def.subject, condition.subject);
-			return [...condition.subject !== void 0 && subject === void 0 ? [`${path}: there is no ${def.subject} "${condition.subject}"`] : [], ...def.kind !== "number" && condition.op !== "eq" && condition.op !== "ne" ? [`${path}: ${def.kind} variables compare with eq or ne only`] : []];
+			const subject = condition.subject === void 0 || self && condition.subject === "@self" ? void 0 : subjectOf(target, def.subject, condition.subject);
+			return [...condition.subject !== void 0 && subject === void 0 && !(self && condition.subject === "@self") ? [`${path}: there is no ${def.subject} "${condition.subject}"`] : [], ...def.kind !== "number" && condition.op !== "eq" && condition.op !== "ne" ? [`${path}: ${def.kind} variables compare with eq or ne only`] : []];
 		}
 		case "item": return [
-			...target.items.list().some((entry) => itemKey(entry) === condition.item) ? [] : [`${path}: there is no item "${condition.item}"`],
+			...self && condition.item === "@self" || target.items.list().some((entry) => itemKey(entry) === condition.item) ? [] : [`${path}: there is no item "${condition.item}"`],
 			...condition.heldBy === void 0 ? [] : character(condition.heldBy),
 			...condition.at === void 0 ? [] : place(condition.at)
 		];
@@ -2322,9 +2896,33 @@ function conditionProblems(target, condition, path, known) {
 		case "fired": return known.has(condition.trigger) ? [] : [`${path}: there is no trigger "${condition.trigger}"`];
 		case "judged": return [];
 		case "all":
-		case "any": return condition.conditions.flatMap((part, index) => conditionProblems(target, part, `${path}.conditions[${index}]`, known));
-		case "not": return conditionProblems(target, condition.condition, `${path}.condition`, known);
-	}
+		case "any": return condition.conditions.flatMap((part, index) => conditionProblems(target, part, `${path}.conditions[${index}]`, known, self));
+		case "not": return conditionProblems(target, condition.condition, `${path}.condition`, known, self);
+	}
+}
+/** What the words of a cue or beat name by `{kind:key}` that the story does not have. */
+function wordsProblems(target, words, path, self) {
+	return placeholdersOf(words).found.flatMap((placeholder) => {
+		const key = placeholder.args[0];
+		const selfKey = self && key === "@self";
+		const missing = (what) => [`${path}: ${placeholder.raw}: there is no ${what} "${key}"`];
+		switch (placeholder.kind) {
+			case "character":
+			case "where": return selfKey || target.characters.list().some((entry) => characterKey(entry) === key) ? [] : missing("character");
+			case "place": return target.locations.list().some((entry) => locationKey(entry) === key) ? [] : missing("place");
+			case "item":
+			case "holder": return target.items.list().some((entry) => itemKey(entry) === key) ? [] : missing("item");
+			case "value": {
+				const def = target.variables.def(key);
+				if (def === void 0) return missing("variable");
+				const subject = placeholder.args[1];
+				if (def.subject === "world") return subject === void 0 ? [] : [`${path}: ${placeholder.raw}: a world variable has no subject`];
+				if (subject === void 0) return [`${path}: ${placeholder.raw}: give the ${def.subject} it is about`];
+				return self && subject === "@self" || subjectOf(target, def.subject, subject) !== void 0 ? [] : [`${path}: ${placeholder.raw}: there is no ${def.subject} "${subject}"`];
+			}
+			case "time": return [];
+		}
+	});
 }
 /**
 * What in a trigger names something the story does not have: a character, place, item or variable in a condition, the characters of a cue,
@@ -2338,10 +2936,12 @@ function triggerReferenceProblems(target, definition, otherKeys = []) {
 		return who.characters.flatMap((key) => target.characters.list().some((entry) => characterKey(entry) === key) ? [] : [`${path}: there is no character "${key}"`]);
 	};
 	const cues = definition.effects.flatMap((effect, index) => effect.type !== "cue" ? [] : audience(effect.audience, `effects[${index}]`));
+	const said = definition.effects.flatMap((effect, index) => effect.type === "edit" ? [] : [...effect.while === void 0 ? [] : conditionProblems(target, effect.while, `effects[${index}].while`, known, effect.type === "cue"), ...wordsProblems(target, effect.text, `effects[${index}].text`, effect.type === "cue")]);
 	const announced = definition.announce === void 0 ? [] : audience(definition.announce.audience, "announce");
 	return [
 		...conditionProblems(target, definition.condition, "when", known),
 		...cues,
+		...said,
 		...announced
 	].map((problem) => `${definition.key}: ${problem}`);
 }
@@ -2374,14 +2974,20 @@ function holds(target, condition, clock) {
 			if (condition.from !== void 0 && now < parseInstant(condition.from, zone)) return false;
 			if (condition.to !== void 0 && now >= parseInstant(condition.to, zone)) return false;
 			const local = localTime(now, zone);
+			const calendar = readCalendar(target.metadata);
+			/** The day a time belongs to: the morning part of a window past midnight belongs to the day before. */
+			const dayAt = (shift) => addLocalDays(now, zone, shift);
+			const onDay = (shift) => {
+				const day = dayAt(shift);
+				return (condition.days === void 0 || condition.days.length === 0 || condition.days.includes(WEEKDAY_NAMES[day.weekday] ?? "")) && (condition.on === void 0 || dayMatches(condition.on, day, calendar));
+			};
 			if (condition.window !== void 0) {
 				const start = parseTimeOfDay(condition.window.from) ?? 0;
 				const end = parseTimeOfDay(condition.window.to) ?? 0;
 				if (!inWindow(local.minuteOfDay, start, end)) return false;
-				const weekday = start > end && local.minuteOfDay < end ? (local.weekday + 6) % 7 : local.weekday;
-				return condition.days === void 0 || condition.days.length === 0 || condition.days.includes(WEEKDAY_NAMES[weekday] ?? "");
+				return onDay(start > end && local.minuteOfDay < end ? -1 : 0);
 			}
-			return condition.days === void 0 || condition.days.length === 0 || condition.days.includes(WEEKDAY_NAMES[local.weekday] ?? "");
+			return onDay(0);
 		}
 		case "place": {
 			const who = target.characters.list().find((entry) => characterKey(entry) === condition.character);
@@ -2503,6 +3109,15 @@ function parseRecordsEdit(value) {
 		}
 		return found;
 	};
+	const numbersOf = (entry, key) => {
+		const found = entry[key];
+		if (found === void 0 || found === null) return void 0;
+		if (!Array.isArray(found) || found.some((item) => typeof item !== "number")) {
+			problems.push(`${key} must be a list of numbers`);
+			return;
+		}
+		return found;
+	};
 	const text = (entry, key) => typeof entry[key] === "string" ? entry[key] : void 0;
 	/** A key, slot or position the model may leave blank instead of leaving out: blank is nothing given, not a name that does not exist. */
 	const named = (entry, key) => {
@@ -2795,13 +3410,19 @@ function parseRecordsEdit(value) {
 			kind: text(entry, "kind") ?? "",
 			text: text(entry, "text") ?? "",
 			about: strings(entry, "about"),
-			importance: num(entry, "importance") ?? 0
+			importance: num(entry, "importance") ?? 0,
+			confidence: text(entry, "confidence"),
+			evidenceFor: numbersOf(entry, "evidence_for"),
+			evidenceAgainst: numbersOf(entry, "evidence_against")
 		})),
 		beliefEdits: array("belief_edits").map((entry) => defined({
 			id: num(entry, "id") ?? 0,
 			text: text(entry, "text"),
 			about: strings(entry, "about"),
-			importance: num(entry, "importance")
+			importance: num(entry, "importance"),
+			confidence: text(entry, "confidence"),
+			evidenceFor: numbersOf(entry, "evidence_for"),
+			evidenceAgainst: numbersOf(entry, "evidence_against")
 		})),
 		beliefRetractions: numbers("belief_retractions"),
 		threadsOpened: Array.isArray(value["threads_opened"]) ? value["threads_opened"].filter((entry) => typeof entry === "string") : [],
@@ -2886,6 +3507,7 @@ function parseRecordsEdit(value) {
 			character: text(entry, "character") ?? "",
 			windows: Array.isArray(entry["windows"]) ? entry["windows"].filter(isObject$1).map((window) => defined({
 				days: strings(window, "days"),
+				on: strings(window, "on"),
 				from: text(window, "from") ?? "",
 				to: text(window, "to") ?? "",
 				activity: text(window, "activity") ?? "",
@@ -2907,6 +3529,21 @@ const scalarValue = {
 	],
 	description: "A number, true or false, or one of the words of a choice."
 };
+const CONFIDENCE = {
+	type: "string",
+	enum: [...MEMORY_CONFIDENCES],
+	description: "How sure the character is: doubtful, likely (the default) or sure. Sure only for what it has seen more than once or cannot doubt."
+};
+const EVIDENCE_FOR = {
+	type: "array",
+	items: { type: "integer" },
+	description: "The numbers of perceptions of the character (from read_records) that this rests on."
+};
+const EVIDENCE_AGAINST = {
+	type: "array",
+	items: { type: "integer" },
+	description: "The numbers of perceptions of the character that speak against this; lower the confidence then."
+};
 const IMPORTANCE = {
 	type: "integer",
 	enum: [
@@ -3067,7 +3704,10 @@ function recordsEditSchema(options = {}) {
 					},
 					text: { type: "string" },
 					about: keys,
-					importance: IMPORTANCE
+					importance: IMPORTANCE,
+					confidence: CONFIDENCE,
+					evidence_for: EVIDENCE_FOR,
+					evidence_against: EVIDENCE_AGAINST
 				},
 				required: [
 					"character",
@@ -3683,7 +4323,7 @@ function recordsEditSchema(options = {}) {
 					},
 					effects: {
 						type: "array",
-						description: "What happens, one to six: {type:\"edit\", edit:{...}} a change of the records in the same format as edit_records (events with a location are seen by those there, variable_changes, exit_changes, item_changes, moves, intents_added, engagements); {type:\"beat\", text} something the game master is told to weave into the story; {type:\"cue\", characters:[keys] (or audience: \"everyone\" | {place:key}), text} something those characters notice; in the events of an edit, perceived_by may be \"everyone\".",
+						description: "What happens, one to six: {type:\"edit\", edit:{...}} a change of the records in the same format as edit_records (events with a location are seen by those there, variable_changes, exit_changes, item_changes, moves, intents_added, engagements); {type:\"beat\", text, while?} something the game master is told to weave into the story; {type:\"cue\", characters:[keys] (or audience: \"everyone\" | {place:key}), text, while?} something those characters notice; a beat or cue is written when it is told, which may be turns after the trigger fired: its text may name things as {character:key}, {place:key}, {item:key}, {where:character} (the place a character is in), {holder:item} (who has it or where it lies), {value:variable} or {value:variable:subject}, {time}, and is told as the story stands then, and `while` is a condition (as above, nothing judged) that must still hold then or it is withdrawn; in a cue \"@self\" stands for the character it is said to (for example while:{type:\"place\", character:\"@self\", location:\"cellar\"}); in the events of an edit, perceived_by may be \"everyone\".",
 						items: {
 							type: "object",
 							properties: { type: {
@@ -3764,6 +4404,11 @@ function recordsEditSchema(options = {}) {
 									},
 									description: "Leave out for every day."
 								},
+								on: {
+									type: "array",
+									items: { type: "string" },
+									description: "Other days it applies on, as well as days: months (dec), dates (12-24, 1912-09-21), stretches (12-20..01-05), dom:1, nth:mon:1 (first Monday), season:winter, holiday:<id>; a ! before one is a day it does not apply on (!holiday:festival). Leave out for every day."
+								},
 								from: {
 									type: "string",
 									description: "HH:MM, 24-hour."
@@ -4129,7 +4774,10 @@ function recordsEditSchema(options = {}) {
 					id: { type: "integer" },
 					text: { type: "string" },
 					about: keys,
-					importance: IMPORTANCE
+					importance: IMPORTANCE,
+					confidence: CONFIDENCE,
+					evidence_for: EVIDENCE_FOR,
+					evidence_against: EVIDENCE_AGAINST
 				},
 				required: ["id"],
 				additionalProperties: false
@@ -4475,26 +5123,49 @@ function applyChanges(target, edit) {
 			perception: one
 		}];
 	});
+	const confidence = (value, where) => {
+		if (value !== void 0 && !MEMORY_CONFIDENCES.includes(value)) problems.push(`${where}: confidence is one of ${MEMORY_CONFIDENCES.join(", ")}`);
+	};
+	/** Perceptions a belief of one character is said to rest on, or to be contradicted by: they must be the character's own. */
+	const evidence = (value, characterId, where) => (value ?? []).flatMap((id) => {
+		const seen = target.events.getPerception(id);
+		if (seen === void 0) {
+			problems.push(`${where}: there is no perception ${id}`);
+			return [];
+		}
+		if (characterId !== void 0 && seen.characterId !== characterId) {
+			problems.push(`${where}: perception ${id} is not one the character took in`);
+			return [];
+		}
+		return [id];
+	});
 	const beliefs = list(edit.beliefs).flatMap((belief, index) => {
 		const where = `beliefs[${index}]`;
 		const character = idOf(belief.character, where);
 		if (!MEMORY_KINDS.includes(belief.kind)) problems.push(`${where}: unknown kind "${String(belief.kind)}"`);
 		if (!present(belief.text)) problems.push(`${where}: say what the character believes or knows`);
 		importance(belief.importance, where);
+		confidence(belief.confidence, where);
 		return character === void 0 ? [] : [{
 			belief,
 			character,
-			about: ids(belief.about, `${where}.about`)
+			about: ids(belief.about, `${where}.about`),
+			evidenceFor: evidence(belief.evidenceFor, character, `${where}.evidence_for`),
+			evidenceAgainst: evidence(belief.evidenceAgainst, character, `${where}.evidence_against`)
 		}];
 	});
 	const beliefEdits = list(edit.beliefEdits).map((change, index) => {
 		const where = `belief_edits[${index}]`;
-		if (target.memories.get(change.id) === void 0) problems.push(`${where}: there is no belief ${change.id}`);
+		const current = target.memories.get(change.id);
+		if (current === void 0) problems.push(`${where}: there is no belief ${change.id}`);
 		if (change.text !== void 0 && !present(change.text)) problems.push(`${where}: say what the character believes or knows`);
 		importance(change.importance, where);
+		confidence(change.confidence, where);
 		return {
 			change,
-			about: change.about === void 0 ? void 0 : ids(change.about, `${where}.about`)
+			about: change.about === void 0 ? void 0 : ids(change.about, `${where}.about`),
+			evidenceFor: evidence(change.evidenceFor, current?.characterId, `${where}.evidence_for`),
+			evidenceAgainst: evidence(change.evidenceAgainst, current?.characterId, `${where}.evidence_against`)
 		};
 	});
 	for (const id of list(edit.beliefRetractions)) if (target.memories.get(id) === void 0) problems.push(`belief_retractions: there is no belief ${id}`);
@@ -4769,23 +5440,30 @@ function applyChanges(target, edit) {
 			learnEventEntities(target.events.get(eventId), perception.characterId);
 			result.writes += 1;
 		}
-		for (const { belief, character, about } of beliefs) {
-			result.beliefIds.push(target.memories.add({
+		for (const { belief, character, about, evidenceFor, evidenceAgainst } of beliefs) {
+			const added = target.memories.add({
 				characterId: character,
 				kind: belief.kind,
 				text: belief.text.trim(),
 				about,
 				importance: belief.importance,
+				...belief.confidence === void 0 ? {} : { confidence: belief.confidence },
 				turn: edit.turn
-			}).id);
+			});
+			result.beliefIds.push(added.id);
+			for (const id of evidenceFor) target.memories.addEvidence(added.id, id, "supports", edit.turn);
+			for (const id of evidenceAgainst) target.memories.addEvidence(added.id, id, "contradicts", edit.turn);
 			result.writes += 1;
 		}
-		for (const { change, about } of beliefEdits) {
+		for (const { change, about, evidenceFor, evidenceAgainst } of beliefEdits) {
 			target.memories.update(change.id, {
 				...change.text === void 0 ? {} : { text: change.text.trim() },
 				...about === void 0 ? {} : { about },
-				...change.importance === void 0 ? {} : { importance: change.importance }
+				...change.importance === void 0 ? {} : { importance: change.importance },
+				...change.confidence === void 0 ? {} : { confidence: change.confidence }
 			});
+			for (const id of evidenceFor) target.memories.addEvidence(change.id, id, "supports", edit.turn);
+			for (const id of evidenceAgainst) target.memories.addEvidence(change.id, id, "contradicts", edit.turn);
 			result.writes += 1;
 		}
 		for (const id of list(edit.beliefRetractions)) {
@@ -5211,6 +5889,139 @@ function lapseNotes(target, turn, kept) {
 	return lapsed;
 }
 //#endregion
+//#region src/records/deferred.ts
+/** The words cannot be written as the story stands: something they name is not there. */
+var UnwritableError = class extends Error {};
+const pad = (value) => String(value).padStart(2, "0");
+function resolve$1(target, placeholder, clock, self) {
+	const key = (index) => placeholder.args[index] === "@self" ? self ?? "@self" : placeholder.args[index];
+	const character = (wanted) => {
+		const found = target.characters.list().find((entry) => characterKey(entry) === wanted);
+		if (found === void 0) throw new UnwritableError(`${placeholder.raw}: there is no character "${wanted}"`);
+		return found;
+	};
+	const place = (wanted) => {
+		const found = target.locations.list().find((entry) => locationKey(entry) === wanted);
+		if (found === void 0) throw new UnwritableError(`${placeholder.raw}: there is no place "${wanted}"`);
+		return found;
+	};
+	const item = (wanted) => {
+		const found = target.items.list().find((entry) => itemKey(entry) === wanted);
+		if (found === void 0) throw new UnwritableError(`${placeholder.raw}: there is no item "${wanted}"`);
+		return found;
+	};
+	switch (placeholder.kind) {
+		case "character": return character(key(0)).name;
+		case "place": return place(key(0)).name;
+		case "item": return item(key(0)).name;
+		case "where": {
+			const who = character(key(0));
+			const at = target.placements.get("character", who.id);
+			const found = at === void 0 ? void 0 : target.locations.get(at.locationId);
+			if (found === void 0) throw new UnwritableError(`${placeholder.raw}: ${who.name} is nowhere in particular`);
+			return found.name;
+		}
+		case "holder": {
+			const thing = item(key(0));
+			const where = target.items.where(thing.id);
+			const holder = where.characterId !== void 0 ? target.characters.get(where.characterId)?.name : where.locationId !== void 0 ? target.locations.get(where.locationId)?.name : void 0;
+			if (holder === void 0) throw new UnwritableError(`${placeholder.raw}: ${thing.name} is nowhere that is known`);
+			return holder;
+		}
+		case "value": {
+			const def = target.variables.def(placeholder.args[0]);
+			if (def === void 0) throw new UnwritableError(`${placeholder.raw}: there is no variable "${placeholder.args[0]}"`);
+			const subject = def.subject === "world" ? { id: 0 } : placeholder.args[1] === void 0 ? void 0 : subjectOf(target, def.subject, key(1));
+			if (subject === void 0) throw new UnwritableError(`${placeholder.raw}: ${def.subject === "world" ? "a world variable has no subject" : `give the ${def.subject} it is about`}`);
+			return describeValue(def, target.variables.value(def.key, def.subject, subject.id));
+		}
+		case "time": {
+			const local = localTime(clock.now, clock.zone);
+			return `${pad(local.hour)}:${pad(local.minute)}`;
+		}
+	}
+}
+/** Words as the story stands now. @throws {UnwritableError} when something they name is not there. */
+function renderWords(target, text, clock, self) {
+	const { found } = placeholdersOf(text);
+	let at = 0;
+	let out = "";
+	for (const placeholder of found) {
+		const start = text.indexOf(placeholder.raw, at);
+		out += text.slice(at, start) + resolve$1(target, placeholder, clock, self);
+		at = start + placeholder.raw.length;
+	}
+	return out + text.slice(at);
+}
+/** A condition with `@self` taken as a character. */
+function bindSelf(condition, self) {
+	const bound = (value) => value === "@self" ? self : value;
+	switch (condition.type) {
+		case "place": return {
+			...condition,
+			character: bound(condition.character)
+		};
+		case "variable": return condition.subject === void 0 ? condition : {
+			...condition,
+			subject: bound(condition.subject)
+		};
+		case "item": return {
+			...condition,
+			item: bound(condition.item),
+			...condition.heldBy === void 0 ? {} : { heldBy: bound(condition.heldBy) }
+		};
+		case "all":
+		case "any": return {
+			...condition,
+			conditions: condition.conditions.map((part) => bindSelf(part, self))
+		};
+		case "not": return {
+			...condition,
+			condition: bindSelf(condition.condition, self)
+		};
+		default: return condition;
+	}
+}
+/** The effect of a trigger that a note was made from: the beat or cue whose words it carries. */
+function noteEffect(trigger, note) {
+	return trigger?.effects.find((effect) => effect.type === note.kind && effect.text === note.text);
+}
+/**
+* Decides, at the moment notes are about to be told, what is still to be told and in what words. A note whose effect says something must
+* still hold and does not hold any more is withdrawn; so is one whose words name something that is not there. Nothing is changed.
+*/
+function deliverNotes(target, notes, clock) {
+	const delivery = {
+		shown: [],
+		withdrawn: []
+	};
+	for (const note of notes) {
+		const effect = noteEffect(target.triggers.get(note.triggerId), note);
+		const self = note.kind === "cue" && note.characterIds[0] !== void 0 ? target.characters.list().find((entry) => entry.id === note.characterIds[0]) : void 0;
+		const who = self === void 0 ? void 0 : characterKey(self);
+		if (effect?.while !== void 0 && !conditionHolds(target, who === void 0 ? effect.while : bindSelf(effect.while, who), clock)) {
+			delivery.withdrawn.push({
+				note,
+				reason: "what it was waiting on no longer holds"
+			});
+			continue;
+		}
+		try {
+			delivery.shown.push({
+				note,
+				text: renderWords(target, note.text, clock, who)
+			});
+		} catch (error) {
+			if (!(error instanceof UnwritableError)) throw error;
+			delivery.withdrawn.push({
+				note,
+				reason: error.message
+			});
+		}
+	}
+	return delivery;
+}
+//#endregion
 //#region src/memory/recall.ts
 const DAY$1 = 864e5;
 const DEFAULT_MEMORY_POLICY = {
@@ -5218,7 +6029,8 @@ const DEFAULT_MEMORY_POLICY = {
 	recall: 12,
 	overRetrieve: 4,
 	associate: 2,
-	diversity: .3
+	diversity: .3,
+	foldedFade: .5
 };
 /** Story days for the memory of an unimportant event to halve; each step of importance doubles it. */
 const HALF_LIFE_DAYS = 6;
@@ -5307,7 +6119,7 @@ function describeEvent({ perception, event }, names, at) {
 		vague: about === "" ? "something happened, but you cannot say what" : `something to do with ${about}`
 	};
 }
-function describeBelief(memory, at) {
+function describeBelief(memory, at, disputed) {
 	return {
 		turn: memory.turn,
 		...at === void 0 ? {} : { at },
@@ -5315,6 +6127,8 @@ function describeBelief(memory, at) {
 			kind: "memory",
 			id: memory.id
 		},
+		confidence: memory.confidence,
+		...disputed ? { disputed: true } : {},
 		clear: memory.text,
 		faded: first(memory.text),
 		vague: first(memory.text)
@@ -5349,7 +6163,9 @@ 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, about }) {
+function gather(source, { characterId, characters, situation, locationId, about, policy }) {
+	const evidence = source.memories.evidenceIndex?.(characterId);
+	const folding = Math.min(1, Math.max(.05, policy?.foldedFade ?? 1));
 	const names = new Map(characters.map((character) => [character.id, character.name]));
 	const peers = mentioned(situation, characters);
 	peers.delete(characterId);
@@ -5389,7 +6205,8 @@ function gather(source, { characterId, characters, situation, locationId, about
 			ageDays: ageDays(at),
 			recalls: seen.perception.recalls,
 			seed: seen.perception.id,
-			durability: 1
+			durability: evidence?.folded.has(seen.perception.id) === true ? folding : 1,
+			...evidence?.folded.has(seen.perception.id) === true ? { covered: evidence.folded.get(seen.perception.id) } : {}
 		};
 	}), ...source.memories.list(characterId).filter((belief) => concerns(belief.about)).map((belief) => {
 		const at = atTurn(belief.turn);
@@ -5404,7 +6221,7 @@ function gather(source, { characterId, characters, situation, locationId, about
 				people: belief.about.filter((id) => id !== characterId),
 				tags: []
 			},
-			recalled: describeBelief(belief, at),
+			recalled: describeBelief(belief, at, evidence?.disputed.has(belief.id) === true),
 			cues: cue,
 			relevance: cue.people + cue.words,
 			importance: belief.importance,
@@ -5564,6 +6381,28 @@ function diversified(ranked, count, diversity) {
 	}
 	return chosen;
 }
+/** How sure the character is of a belief, and whether something since speaks against it. */
+function beliefOf(candidate) {
+	const { confidence, disputed } = candidate.recalled;
+	return {
+		...confidence === void 0 ? {} : { confidence },
+		...disputed === void 0 ? {} : { disputed }
+	};
+}
+/**
+* Chooses as {@link diversified} does, but does not tell what the character took in when a belief resting on it is told as well: the belief says it,
+* and the place goes to the next best.
+*/
+function chooseUncovered(standing, count, diversity) {
+	let pool = standing;
+	for (;;) {
+		const chosen = diversified(pool, count, diversity);
+		const told = new Set(chosen.filter((entry) => entry.candidate.recalled.source.kind === "memory").map((entry) => entry.candidate.recalled.source.id));
+		const repeated = chosen.filter((entry) => entry.candidate.covered?.some((id) => told.has(id)) === true);
+		if (repeated.length === 0) return chosen;
+		pool = pool.filter((entry) => !repeated.includes(entry));
+	}
+}
 /**
 * 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
@@ -5592,13 +6431,14 @@ function finishRecall(pool, rerank) {
 			why
 		}];
 	}).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 chosen = chooseUncovered(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,
+		...beliefOf(candidate),
 		...why === void 0 ? {} : { why }
 	}));
 	const anchors = chosen.filter((entry) => entry.relevance >= CUE_RELEVANCE);
@@ -5620,6 +6460,7 @@ function finishRecall(pool, rerank) {
 			turn: candidate.recalled.turn,
 			...candidate.recalled.at === void 0 ? {} : { at: candidate.recalled.at },
 			source: candidate.recalled.source,
+			...beliefOf(candidate),
 			linked: true,
 			...pool.query.explain === true ? { why: {
 				cues: candidate.cues,
@@ -5769,15 +6610,21 @@ function readRecords(target, scope = {}) {
 				gist: entry.gist
 			}))
 		})),
-		beliefs: characters.flatMap((character) => target.memories.list(character.id).filter((belief) => inScope(belief.turn)).map((belief) => ({
-			id: belief.id,
-			character: characterKey(character),
-			kind: belief.kind,
-			text: belief.text,
-			about: belief.about.map(keyOf),
-			importance: belief.importance,
-			turn: belief.turn
-		}))),
+		beliefs: characters.flatMap((character) => target.memories.list(character.id).filter((belief) => inScope(belief.turn)).map((belief) => {
+			const evidence = target.memories.evidenceOf(belief.id);
+			return {
+				id: belief.id,
+				character: characterKey(character),
+				kind: belief.kind,
+				text: belief.text,
+				about: belief.about.map(keyOf),
+				importance: belief.importance,
+				confidence: belief.confidence,
+				evidence_for: evidence.filter((entry) => entry.relation === "supports").map((entry) => entry.perceptionId),
+				evidence_against: evidence.filter((entry) => entry.relation === "contradicts").map((entry) => entry.perceptionId),
+				turn: belief.turn
+			};
+		})),
 		open_threads: target.threads.list("open").map((thread) => ({
 			id: thread.id,
 			text: thread.text,
@@ -6138,6 +6985,7 @@ const toMemory = (row) => ({
 	text: row.text,
 	about: parseNumberList(row.about, "memories.about"),
 	importance: row.importance,
+	confidence: row.confidence,
 	turn: row.turn,
 	recalls: row.recalls,
 	...row.last_recalled_turn === null ? {} : { lastRecalledTurn: row.last_recalled_turn },
@@ -6154,12 +7002,13 @@ var SqliteMemoryRepository = class {
 	}
 	add(memory) {
 		return guard(() => {
-			const { lastInsertRowid } = this.db.run("INSERT INTO memories (character_id, kind, text, about, importance, turn, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)", [
+			const { lastInsertRowid } = this.db.run("INSERT INTO memories (character_id, kind, text, about, importance, confidence, turn, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)", [
 				memory.characterId,
 				memory.kind,
 				memory.text,
 				toJson(memory.about),
 				memory.importance,
+				memory.confidence ?? "likely",
 				memory.turn,
 				this.clock().toISOString()
 			]);
@@ -6183,10 +7032,11 @@ var SqliteMemoryRepository = class {
 	update(id, patch) {
 		return guard(() => {
 			const current = this.require(id);
-			this.db.run("UPDATE memories SET text = ?, about = ?, importance = ? WHERE id = ?", [
+			this.db.run("UPDATE memories SET text = ?, about = ?, importance = ?, confidence = ? WHERE id = ?", [
 				patch.text ?? current.text,
 				toJson(patch.about ?? current.about),
 				patch.importance ?? current.importance,
+				patch.confidence ?? current.confidence,
 				id
 			]);
 			const changed = this.require(id);
@@ -6208,6 +7058,36 @@ var SqliteMemoryRepository = class {
 		this.index.remove("memory", id);
 		return this.db.run("DELETE FROM memories WHERE id = ?", [id]).changes > 0;
 	}
+	addEvidence(memoryId, perceptionId, relation, turn) {
+		this.require(memoryId);
+		guard(() => this.db.run("INSERT INTO memory_evidence (memory_id, perception_id, relation, turn) VALUES (?, ?, ?, ?) ON CONFLICT (memory_id, perception_id) DO UPDATE SET relation = excluded.relation, turn = excluded.turn", [
+			memoryId,
+			perceptionId,
+			relation,
+			turn
+		]));
+	}
+	evidenceOf(memoryId) {
+		return this.db.all("SELECT * FROM memory_evidence WHERE memory_id = ? ORDER BY perception_id", [memoryId]).map((row) => ({
+			memoryId: row.memory_id,
+			perceptionId: row.perception_id,
+			relation: row.relation,
+			turn: row.turn
+		}));
+	}
+	evidenceIndex(characterId) {
+		const rows = this.db.all("SELECT e.memory_id, e.perception_id, e.relation FROM memory_evidence e JOIN memories m ON m.id = e.memory_id WHERE m.character_id = ? ORDER BY e.memory_id", [characterId]);
+		const folded = /* @__PURE__ */ new Map();
+		const disputed = /* @__PURE__ */ new Set();
+		for (const row of rows) {
+			folded.set(row.perception_id, [...folded.get(row.perception_id) ?? [], row.memory_id]);
+			if (row.relation === "contradicts") disputed.add(row.memory_id);
+		}
+		return {
+			folded,
+			disputed
+		};
+	}
 	require(id) {
 		const memory = this.get(id);
 		if (memory === void 0) throw new NotFoundError(`memory ${id} does not exist`);
@@ -8365,6 +9245,21 @@ const MIGRATIONS = [
       INSERT INTO entity_knowledge SELECT * FROM old_entity_knowledge;
       DROP TABLE old_entity_knowledge;
       CREATE INDEX entity_knowledge_subject ON entity_knowledge (subject_kind, subject_id);
+    `
+	},
+	{
+		version: 7,
+		sql: `
+      ALTER TABLE memories ADD COLUMN confidence TEXT NOT NULL DEFAULT 'likely' CHECK (confidence IN ('doubtful', 'likely', 'sure'));
+      CREATE TABLE memory_evidence (
+        memory_id INTEGER NOT NULL REFERENCES memories (id) ON DELETE CASCADE,
+        perception_id INTEGER NOT NULL REFERENCES perceptions (id) ON DELETE CASCADE,
+        relation TEXT NOT NULL CHECK (relation IN ('supports', 'contradicts')),
+        turn INTEGER NOT NULL,
+        PRIMARY KEY (memory_id, perception_id)
+      ) STRICT;
+      CREATE INDEX memory_evidence_perception ON memory_evidence (perception_id);
+      ALTER TABLE routine_windows ADD COLUMN filters TEXT NOT NULL DEFAULT '[]';
     `
 	}
 ];
@@ -9239,6 +10134,9 @@ var SqliteSessionStore = class {
 	runTriggers(options) {
 		return runTriggers(this, options);
 	}
+	deliverNotes(notes, clock) {
+		return deliverNotes(this, notes, clock);
+	}
 	lapseNotes(turn, kept) {
 		return this.transaction(() => lapseNotes(this, turn, kept));
 	}
@@ -9739,8 +10637,9 @@ function lintWorld(target) {
 //#region src/records/agenda.ts
 /** An engagement still pending this long after it was due (or over) is overdue. */
 const ENGAGEMENT_GRACE = 30 * MINUTE;
-function occurrenceOn(window, day, zone) {
+function occurrenceOn(window, day, zone, calendar) {
 	if (window.days.length > 0 && !window.days.includes(day.weekday)) return void 0;
+	if (window.on.length > 0 && !dayMatches(window.on, day, calendar)) return void 0;
 	const startsAt = zonedInstant({
 		...day,
 		hour: Math.floor(window.start / 60),
@@ -9757,15 +10656,15 @@ function occurrenceOn(window, day, zone) {
 	};
 }
 /** The window that holds at an instant (the first of the list that does), with the stretch of this occurrence of it. */
-function occurrenceAt(windows, now, zone) {
+function occurrenceAt(windows, now, zone, calendar = NO_CALENDAR) {
 	const days = [addLocalDays(now, zone, 0), addLocalDays(now, zone, -1)];
 	for (const window of windows) for (const day of days) {
-		const occurrence = occurrenceOn(window, day, zone);
+		const occurrence = occurrenceOn(window, day, zone, calendar);
 		if (occurrence !== void 0 && occurrence.startsAt <= now && now < occurrence.endsAt) return occurrence;
 	}
 }
 /** The window that starts next after an instant, within `horizon`. */
-function nextOccurrence(windows, now, zone, horizon) {
+function nextOccurrence(windows, now, zone, horizon, calendar = NO_CALENDAR) {
 	let best;
 	for (const offset of [
 		0,
@@ -9774,7 +10673,7 @@ function nextOccurrence(windows, now, zone, horizon) {
 	]) {
 		const day = addLocalDays(now, zone, offset);
 		for (const window of windows) {
-			const occurrence = occurrenceOn(window, day, zone);
+			const occurrence = occurrenceOn(window, day, zone, calendar);
 			if (occurrence === void 0 || occurrence.startsAt <= now || occurrence.startsAt > now + horizon) continue;
 			if (best === void 0 || occurrence.startsAt < best.startsAt) best = occurrence;
 		}
@@ -9807,8 +10706,9 @@ const DEFAULTS = {
 function agendaAt(source, characterId, now, zone, options = {}) {
 	const horizon = options.horizon ?? DEFAULTS.horizon;
 	const windows = source.routines.list(characterId);
-	const current = occurrenceAt(windows, now, zone);
-	const next = nextOccurrence(windows, now, zone, horizon);
+	const calendar = source.metadata === void 0 ? NO_CALENDAR : readCalendar(source.metadata);
+	const current = occurrenceAt(windows, now, zone, calendar);
+	const next = nextOccurrence(windows, now, zone, horizon, calendar);
 	const engagements = source.engagements.list({
 		status: "pending",
 		participant: characterId,
@@ -11324,6 +12224,7 @@ var RoleplayState = class extends Service {
 			edit: (edit, options) => store.edit(edit, options),
 			runTriggers: (options) => store.runTriggers(options),
 			lapseNotes: (turn, kept) => store.lapseNotes(turn, kept),
+			deliverNotes: (notes, clock) => store.deliverNotes(notes, clock),
 			records: (scope) => store.records(scope)
 		};
 		this.sessions.set(key, {
@@ -11560,6 +12461,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, 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 };
+export { ACCURACIES, CHARACTER_CONTROLS, CHARACTER_KINDS, CHARACTER_ROLES, CHARACTER_TIERS, CLOCK_MODES, COMPARISONS, CONSOLIDATION_KINDS, CONTAINER_STATES, Config, ConflictError, CorruptDataError, DAY, DAY_PARTS, DEFAULT_CONFIDENCE, DEFAULT_MEMORY_POLICY, DEFAULT_SLOTS, EMOTION_VARIABLES, ENGAGEMENT_GRACE, ENGAGEMENT_STATUSES, EVIDENCE_RELATIONS, EXIT_STATES, HOUR, IMPORTANCE_MAX, IMPORTANCE_MIN, INTENT_HORIZONS, INTENT_STATUSES, INTENT_TYPES, ITEM_ACTIONS, InvalidEditError, InvalidMoveError, InvalidValueError, KNOWLEDGE_KINDS, LANGUAGES, LORE_KINDS, LORE_SUBJECT_KINDS, MAX_LOCATION_FEATURES, MAX_ROUTINE_WINDOWS, MAX_SHOWN, MAX_TRIGGERS, MAX_VARIABLES, MEMBERSHIP_STATUSES, MEMORY_CONFIDENCES, MEMORY_KINDS, MIGRATION_BACKUP_FOLDER, MINUTE, MONTH_NAMES, NO_CALENDAR, NotFoundError, PERCEPTION_MODES, PLACEABLE_KINDS, PLOT_NUDGE_MODES, PLOT_STATUSES, RECALL_ITEM_KINDS, RoleplayState, LATEST_VERSION as SCHEMA_VERSION, SEASONS, SECOND, SELF, SESSION_DATABASE_FILE, SLOT_ID, SUMMARY_LEVELS, SchemaError, StateError, TEMPLATE_KINDS, THREAD_STATUSES, TIME_CHANGE_KINDS, TRIGGER_NOTE_KINDS, TRIGGER_STATUSES, UnwritableError, 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, dayMatches, dayPart, dayTokenProblems, deleteSession, deliverNotes, denseScore, describeDuration, describeHolder, describeInstant, describeValue, finishRecall, fuseScores, holidaysOn, inAudience, inWindow, isSessionId, isTimeZone, itemKey, jitter, judgedStatements, languageOf, lapseNotes, lintWorld, listSessions, localIso, localTime, locationKey, mentioned, migrationBackupPath, moveCharacter, name, nextOccurrence, nextTimeOfDay, nodeSqliteDriver, occurrenceAt, openSession, openSessionStore, overlap, parseDayToken, parseInstant, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, placeholdersOf, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readCalendar, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, renderWords, retention, runTriggers, seasonOf, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemTimeZone, tokens, translated, translation, translator, triggerReferenceProblems, valueIssue, writeCalendar, zonedInstant };
 
 //# sourceMappingURL=index.js.map