@dsh-agentic-roleplay/state 0.3.0 → 0.3.2

package/lib/index.js

@@ -3,7 +3,7 @@ import { DatabaseSync } from "node:sqlite";
 import { dirname, join, resolve } from "node:path";
 import { Service } from "@deepseek-ai/cordis";
 import z from "@deepseek-ai/schemastery";
-import { randomUUID } from "node:crypto";
+import { randomInt, randomUUID } from "node:crypto";
 import { copyFileSync, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from "node:fs";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 //#region ../dsh-roleplay-model/src/character.ts
@@ -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"];
@@ -358,6 +367,31 @@ const TRIGGER_NOTE_KINDS = ["beat", "cue"];
 /** At most this many triggers in a story. */
 const MAX_TRIGGERS = 200;
 //#endregion
+//#region ../dsh-roleplay-model/src/dice.ts
+/** What a band of a check makes of an attempt; the same three results a round's outcome has. */
+const DICE_RESULTS = [
+	"succeeded",
+	"partial",
+	"failed"
+];
+/** How a roll is read: by its total, or by how many of the dice came up high enough. */
+const DICE_READINGS = ["total", "successes"];
+/**
+* What the value is compared with: `absolute` reads the value itself, `over` the amount by which it beats the target
+* (a difficulty to meet or exceed), `under` the amount by which it stays below the target (a skill to roll under).
+*/
+const DICE_COMPARISONS = [
+	"absolute",
+	"over",
+	"under"
+];
+/** Rolls and checks are limited so that a story cannot grow without bound. */
+const MAX_DICE_CHECKS = 40;
+const MAX_DICE_BANDS = 20;
+const MAX_DICE_PER_ROLL = 100;
+const MAX_DICE_SIDES = 1e3;
+const MAX_DICE_TERMS = 8;
+//#endregion
 //#region ../dsh-roleplay-model/src/visual.ts
 const VISUAL_SUBJECT_KINDS = [
 	"character",
@@ -403,6 +437,227 @@ 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}",
+	"- {key} ({name}): {use}": "- {key}（{name}）：{use}",
+	"Rolls {dice}.": "掷 {dice}。",
+	"Give a target: the difficulty, the number to meet or beat; set it by how hard the attempt is.": "需给出 target：难度，即要达到或超过的数字；按这次尝试的难易来定。",
+	"Give a target: the number to stay under; set it by how hard the attempt is.": "需给出 target：要低于的数字；按这次尝试的难易来定。",
+	"It adds the character's {variable}.": "它会加上该角色的 {variable}。",
+	"Counts the dice that show {hit} or more.": "统计显示 {hit} 或更高的骰子数。",
+	"the player's roll": "玩家的掷骰",
+	"The player rolled {dice} ({reason}) and got {total}: dice {faces}. This is a fact, decided by the dice: take it into account when you judge the attempt and decide what happens.": "玩家掷了 {dice}（{reason}），得到 {total}：骰面 {faces}。这是由骰子决定的事实：在你判断这次尝试、决定发生什么时把它考虑进去。",
+	"The checks of this story:": "本故事的检定：",
+	"No checks are defined: use roll_dice only.": "没有定义检定：只用 roll_dice。",
+	"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; leave it out to keep the belief as it is": "{where}：文字不能为空，且最多 {max} 个字符；想保持信念原样就不要写这一项",
+	"{where}: the confidence, the importance and the numbers are fields of their own, not part of the text": "{where}：把握程度、重要性和编号是各自独立的字段，不属于文字",
+	"{where}: name what speaks against the belief in contradicted_by": "{where}：在 contradicted_by 里写出与该信念相悖的内容的编号",
+	"{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}。",
+	"## MCP resource servers\n\nUse {tools} with the server argument naming an MCP server.": "## MCP 资源服务器\n\n使用 {tools}，server 参数填 MCP 服务器的名称。",
+	"## MCP resource servers\n\nUse {tools} with one of these names as the server argument: {servers}.": "## MCP 资源服务器\n\n使用 {tools}，server 参数填下列名称之一：{servers}。"
+};
+//#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
@@ -562,6 +817,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,
@@ -595,10 +851,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(),
@@ -707,6 +964,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$1(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$1(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;
@@ -834,9 +1311,19 @@ 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);
+	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. */
@@ -856,9 +1343,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],
@@ -1114,6 +1617,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);
@@ -1122,6 +1627,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(),
@@ -2143,8 +2649,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`);
@@ -2155,7 +2664,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": {
@@ -2407,7 +2917,7 @@ 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);
@@ -2503,14 +3013,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);
@@ -2632,6 +3148,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) => {
@@ -2924,13 +3449,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") : [],
@@ -3015,6 +3546,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") ?? "",
@@ -3036,6 +3568,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: [
@@ -3196,7 +3743,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",
@@ -3893,6 +4443,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."
@@ -4258,7 +4813,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
@@ -4604,26 +5162,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}`);
@@ -4898,23 +5479,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)) {
@@ -5480,7 +6068,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;
@@ -5569,7 +6158,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 },
@@ -5577,6 +6166,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)
@@ -5611,7 +6202,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);
@@ -5651,7 +6244,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);
@@ -5666,7 +6260,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,
@@ -5826,6 +6420,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
@@ -5854,13 +6470,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);
@@ -5882,6 +6499,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,
@@ -6031,15 +6649,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,
@@ -6400,6 +7024,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 },
@@ -6416,12 +7041,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()
 			]);
@@ -6445,10 +7071,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);
@@ -6470,6 +7097,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`);
@@ -6920,6 +7577,108 @@ var SqliteTriggerRepository = class {
 	}
 };
 //#endregion
+//#region src/sqlite/dice-repository.ts
+const MAX_ROLLS_LISTED = 200;
+function parseDefinition(text) {
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		throw new CorruptDataError("a dice check's definition is not valid JSON", { cause: error });
+	}
+}
+var SqliteDiceRepository = class {
+	db;
+	clock;
+	constructor(db, clock) {
+		this.db = db;
+		this.clock = clock;
+	}
+	define(definition) {
+		if ((this.db.get("SELECT count(*) AS count FROM dice_checks")?.count ?? 0) >= 40) throw new InvalidValueError(`a story has at most 40 dice checks`);
+		const { key, name, use, ...rest } = definition;
+		return guard(() => {
+			const { lastInsertRowid } = this.db.run("INSERT INTO dice_checks (key, name, use_text, definition) VALUES (?, ?, ?, ?)", [
+				key,
+				name,
+				use,
+				toJson(rest)
+			]);
+			return this.require(Number(lastInsertRowid));
+		});
+	}
+	checks() {
+		return this.db.all("SELECT * FROM dice_checks ORDER BY id").map((row) => this.toCheck(row));
+	}
+	check(key) {
+		const row = this.db.get("SELECT * FROM dice_checks WHERE key = ?", [key]);
+		return row === void 0 ? void 0 : this.toCheck(row);
+	}
+	removeCheck(key) {
+		if (this.db.run("DELETE FROM dice_checks WHERE key = ?", [key]).changes === 0) throw new NotFoundError(`there is no dice check "${key}"`);
+	}
+	record(roll) {
+		const at = this.clock().toISOString();
+		const { lastInsertRowid } = this.db.run("INSERT INTO dice_rolls (turn, check_key, expression, faces, kept, modifier, target, total, value, readout, reason, character, by, at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)", [
+			roll.turn,
+			roll.check ?? null,
+			roll.expression,
+			toJson(roll.faces),
+			toJson(roll.kept),
+			roll.modifier,
+			roll.target ?? null,
+			roll.total,
+			roll.value,
+			roll.readout === void 0 ? null : toJson(roll.readout),
+			roll.reason,
+			roll.character ?? null,
+			roll.by,
+			at
+		]);
+		return {
+			...roll,
+			id: Number(lastInsertRowid),
+			at
+		};
+	}
+	rolls(filter = {}) {
+		const limit = Math.min(filter.limit ?? MAX_ROLLS_LISTED, MAX_ROLLS_LISTED);
+		return (filter.turn === void 0 ? this.db.all("SELECT * FROM (SELECT * FROM dice_rolls ORDER BY id DESC LIMIT ?) ORDER BY id", [limit]) : this.db.all("SELECT * FROM dice_rolls WHERE turn = ? ORDER BY id LIMIT ?", [filter.turn, limit])).map((row) => this.toRoll(row));
+	}
+	require(id) {
+		const row = this.db.get("SELECT * FROM dice_checks WHERE id = ?", [id]);
+		if (row === void 0) throw new NotFoundError(`there is no dice check ${id}`);
+		return this.toCheck(row);
+	}
+	toCheck(row) {
+		return {
+			id: row.id,
+			key: row.key,
+			name: row.name,
+			use: row.use_text,
+			...parseDefinition(row.definition)
+		};
+	}
+	toRoll(row) {
+		return {
+			id: row.id,
+			turn: row.turn,
+			expression: row.expression,
+			faces: parseNumberList(row.faces, "dice_rolls.faces"),
+			kept: parseNumberList(row.kept, "dice_rolls.kept"),
+			modifier: row.modifier,
+			total: row.total,
+			value: row.value,
+			reason: row.reason,
+			by: row.by,
+			at: row.at,
+			...row.check_key === null ? {} : { check: row.check_key },
+			...row.target === null ? {} : { target: row.target },
+			...row.readout === null ? {} : { readout: JSON.parse(row.readout) },
+			...row.character === null ? {} : { character: row.character }
+		};
+	}
+};
+//#endregion
 //#region src/sqlite/clock-repository.ts
 const toChange = (row) => ({
 	id: row.id,
@@ -8063,7 +8822,7 @@ var SqliteMetadataRepository = class {
 //#region src/sqlite/schema.ts
 /**
 * Migrations are applied in order and never edited once released (0.1.0 released
-* versions 1 to 6; tests/sqlite/migrate.spec.ts pins them): a change to the schema
+* versions 1 to 6; tests/sqlite/migrate.spec.ts pins the released ones): a change to the schema
 * is a new entry. Enumerations are spelled out so that a later change to the model
 * cannot alter what an old migration did.
 */
@@ -8627,6 +9386,51 @@ 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 '[]';
+    `
+	},
+	{
+		version: 8,
+		sql: `
+      CREATE TABLE dice_checks (
+        id INTEGER PRIMARY KEY,
+        key TEXT NOT NULL UNIQUE,
+        name TEXT NOT NULL,
+        use_text TEXT NOT NULL,
+        definition TEXT NOT NULL
+      ) STRICT;
+      CREATE TABLE dice_rolls (
+        id INTEGER PRIMARY KEY,
+        turn INTEGER NOT NULL,
+        check_key TEXT,
+        expression TEXT NOT NULL,
+        faces TEXT NOT NULL,
+        kept TEXT NOT NULL,
+        modifier INTEGER NOT NULL,
+        target INTEGER,
+        total INTEGER NOT NULL,
+        value INTEGER NOT NULL,
+        readout TEXT,
+        reason TEXT NOT NULL,
+        character TEXT,
+        by TEXT NOT NULL CHECK (by IN ('agent', 'player')),
+        at TEXT NOT NULL
+      ) STRICT;
+      CREATE INDEX dice_rolls_turn ON dice_rolls (turn, id);
     `
 	}
 ];
@@ -9375,6 +10179,7 @@ var SqliteSessionStore = class {
 	routines;
 	engagements;
 	triggers;
+	dice;
 	recallIndex;
 	eventRepository;
 	constructor(db, clock, vectors) {
@@ -9405,6 +10210,7 @@ var SqliteSessionStore = class {
 		this.routines = new SqliteRoutineRepository(db);
 		this.engagements = new SqliteEngagementRepository(db);
 		this.triggers = new SqliteTriggerRepository(db);
+		this.dice = new SqliteDiceRepository(db, clock);
 		this.eventRepository = new SqliteEventRepository(db, clock, this.recallIndex, (id) => this.locations.get(id)?.name, (id) => this.items.get(id)?.name);
 		this.events = this.eventRepository;
 		this.memories = new SqliteMemoryRepository(db, clock, this.recallIndex);
@@ -9811,6 +10617,375 @@ function identityOf(database, storeOptions) {
 	}
 }
 //#endregion
+//#region src/records/dice.ts
+const systemRoller = (sides) => randomInt(1, sides + 1);
+const TERM = /^(?:(\d*)d(\d+|%)(?:(kh|kl|dh|dl)(\d*))?|(\d+))$/;
+/** Reads dice notation: `2d6+1`, `d20`, `4d6kh3`, `d%`, `1d8+1d4-1`. @throws {InvalidValueError} with what is wrong. */
+function parseNotation(input) {
+	const source = input.toLowerCase().replace(/\s+/g, "");
+	if (source === "") throw new InvalidValueError("dice notation is empty: write it like 2d6+1");
+	const parts = source.split(/(?=[+-])/);
+	if (parts.length > 8) throw new InvalidValueError(`dice notation has more than 8 terms`);
+	const terms = parts.map((part, index) => {
+		const sign = part.startsWith("-") ? -1 : 1;
+		const body = part.replace(/^[+-]/, "");
+		if (index > 0 && !/^[+-]/.test(part)) throw new InvalidValueError(`"${input}" is not dice notation: write it like 2d6+1`);
+		const match = TERM.exec(body);
+		if (match === null) throw new InvalidValueError(`"${part}" is not dice notation: write it like 2d6+1, 4d6kh3 or d100`);
+		if (match[5] !== void 0) return {
+			sign,
+			constant: Number(match[5])
+		};
+		const count = match[1] === "" || match[1] === void 0 ? 1 : Number(match[1]);
+		const sides = match[2] === "%" ? 100 : Number(match[2]);
+		if (count < 1 || count > 100) throw new InvalidValueError(`"${part}": roll from 1 to 100 dice at a time`);
+		if (sides < 2 || sides > 1e3) throw new InvalidValueError(`"${part}": a die has from 2 to ${MAX_DICE_SIDES} sides`);
+		const mode = match[3];
+		if (mode === void 0) return {
+			sign,
+			count,
+			sides
+		};
+		const n = match[4] === "" || match[4] === void 0 ? 1 : Number(match[4]);
+		if (n < 1 || n >= count) throw new InvalidValueError(`"${part}": ${mode.startsWith("k") ? "keep" : "drop"} at least 1 and fewer than the ${count} dice`);
+		return {
+			sign,
+			count,
+			sides,
+			keep: {
+				mode,
+				n
+			}
+		};
+	});
+	if (!terms.some((term) => "sides" in term)) throw new InvalidValueError(`"${input}" has no dice: write it like 2d6+1`);
+	return {
+		text: source,
+		terms
+	};
+}
+/** The lowest and highest total the dice and constants can give. */
+function notationRange(notation) {
+	let min = 0;
+	let max = 0;
+	for (const term of notation.terms) {
+		if ("constant" in term) {
+			min += term.sign * term.constant;
+			max += term.sign * term.constant;
+			continue;
+		}
+		const kept = term.keep === void 0 ? term.count : term.keep.mode.startsWith("k") ? term.keep.n : term.count - term.keep.n;
+		const low = kept;
+		const high = kept * term.sides;
+		min += term.sign === 1 ? low : -high;
+		max += term.sign === 1 ? high : -low;
+	}
+	return {
+		min,
+		max
+	};
+}
+function keepOf(faces, keep) {
+	const ordered = faces.map((face, index) => ({
+		face,
+		index
+	})).sort((a, b) => a.face - b.face || a.index - b.index);
+	const count = keep.mode.startsWith("k") ? keep.n : faces.length - keep.n;
+	return (keep.mode === "kh" || keep.mode === "dl" ? ordered.slice(ordered.length - count) : ordered.slice(0, count)).sort((a, b) => a.index - b.index).map((entry) => entry.face);
+}
+function rollNotation(notation, roll = systemRoller) {
+	const faces = [];
+	const kept = [];
+	let constant = 0;
+	let total = 0;
+	for (const term of notation.terms) {
+		if ("constant" in term) {
+			constant += term.sign * term.constant;
+			total += term.sign * term.constant;
+			continue;
+		}
+		const thrown = Array.from({ length: term.count }, () => roll(term.sides));
+		const counted = term.keep === void 0 ? thrown : keepOf(thrown, term.keep);
+		faces.push(...thrown);
+		kept.push(...counted);
+		total += term.sign * counted.reduce((sum, face) => sum + face, 0);
+	}
+	return {
+		faces,
+		kept,
+		constant,
+		total
+	};
+}
+const within = (band, value) => (band.min === void 0 || value >= band.min) && (band.max === void 0 || value <= band.max);
+/** What the bands of a check make of a value. @throws {InvalidValueError} when no band holds it. */
+function readBands(bands, value) {
+	const band = bands.find((candidate) => within(candidate, value));
+	if (band === void 0) throw new InvalidValueError(`no band of this check holds ${value}: the check's bands leave a gap`);
+	return {
+		label: band.label,
+		result: band.result,
+		critical: band.critical === true
+	};
+}
+/**
+* Rolls a check: the dice, the character's modifier and any bonus added, then the value read against the bands. With the reading
+* `successes` the total is the number of dice that hit. A check read against a target needs one.
+* @throws {InvalidValueError} for a target a check needs and is not given, or bands that leave the value unread.
+*/
+function rollCheck(check, input, roll = systemRoller) {
+	const rolled = rollNotation(parseNotation(check.dice), roll);
+	const comparison = check.compare ?? "absolute";
+	if (comparison !== "absolute" && input.target === void 0) throw new InvalidValueError(`the check "${check.key}" is read against a target (${comparison === "over" ? "the number to meet or beat" : "the number to stay under"}): give one`);
+	const added = (input.modifier ?? 0) + (input.bonus ?? 0);
+	const total = check.reading === "successes" ? rolled.kept.filter((face) => face >= (check.hit ?? 0)).length + (input.bonus ?? 0) : rolled.total + added;
+	const value = comparison === "over" ? total - (input.target ?? 0) : comparison === "under" ? (input.target ?? 0) - total : total;
+	return {
+		faces: rolled.faces,
+		kept: rolled.kept,
+		modifier: check.reading === "successes" ? input.bonus ?? 0 : rolled.constant + added,
+		...input.target === void 0 ? {} : { target: input.target },
+		total,
+		value,
+		readout: readBands(check.bands, value)
+	};
+}
+/** What is wrong with a check as a world defines it; nothing when it is sound. */
+function checkProblems(check) {
+	const problems = [];
+	if (!/^[a-z][a-z0-9_-]{0,39}$/.test(check.key)) problems.push(`the key "${check.key}" must be lower-case letters, digits, - or _, starting with a letter`);
+	if (check.name.trim() === "") problems.push("it needs a name");
+	if (check.use.trim() === "") problems.push("it needs a \"use\": when the game master rolls it");
+	if (check.compare !== void 0 && !DICE_COMPARISONS.includes(check.compare)) problems.push(`"compare" must be one of: ${DICE_COMPARISONS.join(", ")}`);
+	if (check.reading !== void 0 && !DICE_READINGS.includes(check.reading)) problems.push(`"reading" must be one of: ${DICE_READINGS.join(", ")}`);
+	let notation;
+	try {
+		notation = parseNotation(check.dice);
+	} catch (error) {
+		problems.push(`"dice": ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (check.bands.length === 0) problems.push("it needs at least one band");
+	if (check.bands.length > 20) problems.push(`it has more than 20 bands`);
+	check.bands.forEach((band, index) => {
+		if (band.label.trim() === "") problems.push(`band ${index + 1} needs a label`);
+		if (!DICE_RESULTS.includes(band.result)) problems.push(`band ${index + 1}: "result" must be one of: ${DICE_RESULTS.join(", ")}`);
+		if (band.min !== void 0 && band.max !== void 0 && band.min > band.max) problems.push(`band ${index + 1}: min is above max`);
+	});
+	if (check.reading === "successes") {
+		const sides = notation?.terms.flatMap((term) => "sides" in term ? [term.sides] : []) ?? [];
+		if (check.hit === void 0 || !Number.isInteger(check.hit) || check.hit < 1 || sides.length > 0 && check.hit > Math.max(...sides)) problems.push("the reading \"successes\" needs \"hit\": the lowest face that counts");
+	}
+	if (notation !== void 0 && problems.length === 0 && (check.compare ?? "absolute") === "absolute" && check.modifier === void 0) {
+		const { min, max } = check.reading === "successes" ? {
+			min: 0,
+			max: notation.terms.reduce((sum, term) => sum + ("count" in term ? term.count : 0), 0)
+		} : notationRange(notation);
+		for (let value = min; value <= max; value += 1) if (!check.bands.some((band) => within(band, value))) {
+			problems.push(`no band holds ${value}, which the dice can give`);
+			break;
+		}
+	}
+	return problems;
+}
+function rollPlain(expression, roll = systemRoller) {
+	const notation = parseNotation(expression);
+	const rolled = rollNotation(notation, roll);
+	return {
+		expression: notation.text,
+		faces: rolled.faces,
+		kept: rolled.kept,
+		modifier: rolled.constant,
+		total: rolled.total
+	};
+}
+//#endregion
+//#region src/tools/dice.ts
+const ROLL_DICE_TOOL = "roll_dice";
+const ROLL_CHECK_TOOL = "roll_check";
+const LIST_CHECKS_TOOL = "list_checks";
+const sign = (value) => value >= 0 ? `+${value}` : String(value);
+/** How a roll reads to the agent that asked for it: what fell, what it adds up to, and what the world's check makes of it. */
+function describeRoll(roll, check) {
+	const dice = `[${roll.faces.join(", ")}]${roll.kept.length < roll.faces.length ? ` keeping [${roll.kept.join(", ")}]` : ""}`;
+	const lines = [`Roll ${roll.id}: ${roll.expression}${check === void 0 ? "" : ` for the check "${check.name}"`}${roll.character === void 0 ? "" : ` (${roll.character})`} - ${dice}${roll.modifier === 0 ? "" : ` ${sign(roll.modifier)}`} = ${roll.total}${check?.reading === "successes" ? " successes" : ""}.`];
+	if (roll.target !== void 0) lines.push(`Against ${roll.target}: ${roll.value >= 0 ? "+" : ""}${roll.value}.`);
+	if (roll.readout !== void 0) lines.push(`That is: ${roll.readout.label}${roll.readout.critical ? " (critical)" : ""}; the result is ${roll.readout.result}. This is decided by the dice: do not change it, narrate it.${check === void 0 || roll.character === void 0 ? "" : ` In resolve_round give ${roll.character}'s outcome this result and cite the roll: roll ${roll.id}.`}`);
+	return lines.join(" ");
+}
+const rolled = (_args, value) => [{
+	type: "text",
+	text: value.text
+}];
+/**
+* Tools that roll dice for an agent, so that numbers are not made up. `roll_check` rolls a check the story defines and reads
+* the result with the check's own bands; `roll_dice` rolls plain notation for what has no check. The roller is the system's
+* source of randomness unless one is given.
+*/
+function createDiceTools(resolve, options = {}) {
+	const roller = options.roller ?? systemRoller;
+	const linkOf = (agent) => {
+		const found = agent === void 0 ? void 0 : resolve(agent.session.id);
+		if (found === void 0) throw new NotFoundError("this agent is not working in a roleplay session, so there are no dice to roll");
+		return found;
+	};
+	return [
+		defineTool({
+			name: LIST_CHECKS_TOOL,
+			description: "List the checks this story defines for settling uncertain attempts: when each is used, the dice it rolls and how its result is read.",
+			parameters: {},
+			output: {
+				schema: { type: "json" },
+				render: (_args, value) => [{
+					type: "text",
+					text: JSON.stringify(value, null, 2)
+				}]
+			},
+			isConcurrencySafe: () => true,
+			execute(_args, exec) {
+				const { session } = linkOf(exec.agent);
+				return Promise.resolve(session.dice.checks().map((check) => ({
+					key: check.key,
+					name: check.name,
+					use: check.use,
+					dice: check.dice,
+					compare: check.compare ?? "absolute",
+					...check.modifier === void 0 ? {} : { modifier: `the character's ${check.modifier}` },
+					bands: check.bands.map((band) => ({
+						...band.min === void 0 ? {} : { from: band.min },
+						...band.max === void 0 ? {} : { to: band.max },
+						label: band.label,
+						result: band.result
+					}))
+				})));
+			}
+		}),
+		defineTool({
+			name: ROLL_CHECK_TOOL,
+			description: "Roll one of the story's checks for an attempt whose outcome is uncertain and matters: the dice are rolled for you and the result is read with the check's own bands, so you never choose or make up a number. Use the check whose \"use\" fits (list_checks shows them). Roll once per attempt, before you decide what happens, and let the result stand: a failed roll is a failure, whatever the story would like.",
+			parameters: {
+				check: {
+					type: "string",
+					required: true,
+					description: "The key of the check, as list_checks gives it."
+				},
+				reason: {
+					type: "string",
+					required: true,
+					description: "What is attempted, by whom, in a sentence."
+				},
+				character: {
+					type: "string",
+					required: true,
+					description: "The key of the character the attempt is for (the player's character included): the roll is theirs, and their outcome in resolve_round takes its result from it."
+				},
+				target: {
+					type: "integer",
+					description: "When the check is read against a target (list_checks says compare over or under): the difficulty, the number the total must meet or beat (or stay under). Set it by how hard the attempt is, using what the check's \"use\" says about difficulty; never 0 to make it easy."
+				},
+				bonus: {
+					type: "integer",
+					description: "What the circumstances add to or take from the roll, from -10 to 10; leave out for none."
+				}
+			},
+			output: {
+				schema: { type: "json" },
+				render: rolled
+			},
+			isConcurrencySafe: () => false,
+			execute(args, exec) {
+				const { session, turn } = linkOf(exec.agent);
+				const check = session.dice.check(args.check);
+				if (check === void 0) throw new NotFoundError(`there is no check "${args.check}"; list_checks shows the story's checks`);
+				if (session.characters.list().every((entry) => characterKey(entry) !== args.character)) throw new NotFoundError(`there is no character "${args.character}"; list_characters shows the keys`);
+				let modifier;
+				if (check.modifier !== void 0) {
+					const who = session.characters.list().find((entry) => characterKey(entry) === args.character);
+					if (who === void 0) throw new NotFoundError(`there is no character "${args.character}"; list_characters shows the keys`);
+					const value = session.variables.value(check.modifier, "character", who.id);
+					if (typeof value !== "number") throw new NotFoundError(`the character's ${check.modifier} is not a number, so the check cannot add it`);
+					modifier = value;
+				}
+				const bonus = Math.max(-10, Math.min(10, args.bonus ?? 0));
+				const made = rollCheck(check, {
+					...modifier === void 0 ? {} : { modifier },
+					bonus,
+					...args.target === void 0 ? {} : { target: args.target }
+				}, roller);
+				const roll = session.dice.record({
+					turn,
+					check: check.key,
+					expression: check.dice,
+					faces: made.faces,
+					kept: made.kept,
+					modifier: made.modifier,
+					...made.target === void 0 ? {} : { target: made.target },
+					total: made.total,
+					value: made.value,
+					readout: made.readout,
+					reason: args.reason,
+					character: args.character,
+					by: options.by ?? "agent"
+				});
+				return Promise.resolve({
+					roll: roll.id,
+					check: check.key,
+					total: roll.total,
+					result: made.readout.result,
+					label: made.readout.label,
+					critical: made.readout.critical,
+					text: describeRoll(roll, check)
+				});
+			}
+		}),
+		defineTool({
+			name: ROLL_DICE_TOOL,
+			description: "Roll dice for something the story has no check for (damage, a random pick, who goes first, a rumour table): the dice are rolled for you, so you never make up a number. Write the notation like 1d6, 2d4+1, 4d6kh3 (keep the highest 3) or d100. What the number means is for you to decide from the rules you were given; when a check fits the attempt, use roll_check instead.",
+			parameters: {
+				expression: {
+					type: "string",
+					required: true,
+					description: "Dice notation, for example 2d6+1."
+				},
+				reason: {
+					type: "string",
+					required: true,
+					description: "What the roll is for, in a sentence."
+				},
+				character: {
+					type: "string",
+					description: "The key of the character it is for, when it is for one."
+				}
+			},
+			output: {
+				schema: { type: "json" },
+				render: rolled
+			},
+			isConcurrencySafe: () => false,
+			execute(args, exec) {
+				const { session, turn } = linkOf(exec.agent);
+				const made = rollPlain(args.expression, roller);
+				const roll = session.dice.record({
+					turn,
+					expression: made.expression,
+					faces: made.faces,
+					kept: made.kept,
+					modifier: made.modifier,
+					total: made.total,
+					value: made.total,
+					reason: args.reason,
+					...args.character === void 0 ? {} : { character: args.character },
+					by: options.by ?? "agent"
+				});
+				return Promise.resolve({
+					roll: roll.id,
+					total: roll.total,
+					text: describeRoll(roll)
+				});
+			}
+		})
+	];
+}
+//#endregion
 //#region src/records/lint.ts
 /**
 * What is inconsistent or unfinished in the world's graph of places and characters. Things made up in
@@ -10004,8 +11179,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),
@@ -10022,15 +11198,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,
@@ -10039,7 +11215,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;
 		}
@@ -10072,8 +11248,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,
@@ -11396,7 +12573,8 @@ function createTools(resolve, options) {
 //#region src/plugin.ts
 const Config = z.object({
 	journalMode: z.union(["delete", "wal"]).default("delete"),
-	writeTools: z.boolean().default(false)
+	writeTools: z.boolean().default(false),
+	diceTools: z.boolean().default(false)
 });
 /**
 * Roleplay session state for other plugins. It creates and opens sessions
@@ -11422,6 +12600,7 @@ var RoleplayState = class extends Service {
 		};
 		ctx.inject(["tools"], (scope) => {
 			for (const tool of createTools(resolve, { write: config.writeTools ?? false })) scope.tools.register(tool);
+			if (config.diceTools === true) for (const tool of createDiceTools(resolve)) scope.tools.register(tool);
 		});
 	}
 	/**
@@ -11557,6 +12736,7 @@ var RoleplayState = class extends Service {
 			routines: store.routines,
 			engagements: store.engagements,
 			triggers: store.triggers,
+			dice: store.dice,
 			planMove: (characterId, move) => store.planMove(characterId, move),
 			planKnownMove: (characterId, move) => store.planKnownMove(characterId, move),
 			move: (characterId, move) => store.move(characterId, move),
@@ -11826,6 +13006,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, 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, dayPart, deleteSession, deliverNotes, 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, placeholdersOf, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, renderWords, 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, DICE_COMPARISONS, DICE_READINGS, DICE_RESULTS, 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, LIST_CHECKS_TOOL, LORE_KINDS, LORE_SUBJECT_KINDS, MAX_DICE_BANDS, MAX_DICE_CHECKS, MAX_DICE_PER_ROLL, MAX_DICE_SIDES, MAX_DICE_TERMS, 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, ROLL_CHECK_TOOL, ROLL_DICE_TOOL, 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, checkProblems, clarityAt, clockTime, conditionHolds, createCharacterTools, createDiceTools, createSession, createSessionStore, createTools, dayMatches, dayPart, dayTokenProblems, deleteSession, deliverNotes, denseScore, describeDuration, describeHolder, describeInstant, describeRoll, 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, notationRange, occurrenceAt, openSession, openSessionStore, overlap, parseDayToken, parseInstant, parseNotation, parseRecordsEdit, parseTimeOfDay, parseTriggerDefinition, placeholdersOf, planItemChange, planKnownMove, planMove, planVariableChange, poolCandidates, rankGoals, readBands, readCalendar, readRecords, readTriggerDefinition, recall, recallCandidates, recallPool, recordsEditSchema, renderWords, retention, rollCheck, rollNotation, rollPlain, runTriggers, seasonOf, seededRoll, sessionDatabase, sessionFolder, shownVariables, subjectOf, systemClock, systemRoller, systemTimeZone, tokens, translated, translation, translator, triggerReferenceProblems, valueIssue, writeCalendar, zonedInstant };
 
 //# sourceMappingURL=index.js.map