@ouro.bot/cli 0.1.0-alpha.88 → 0.1.0-alpha.880

package/dist/heart/session-stats.js

@@ -0,0 +1,183 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeSessionStats = computeSessionStats;
+exports.runSessionStats = runSessionStats;
+exports.formatStatsReport = formatStatsReport;
+exports.runSessionStatsCli = runSessionStatsCli;
+const fs = __importStar(require("node:fs"));
+const session_events_1 = require("./session-events");
+const ROLES = ["system", "user", "assistant", "tool"];
+function emptyByRole() {
+    const counts = {};
+    for (const role of ROLES)
+        counts[role] = 0;
+    return counts;
+}
+function eventTimeMs(event) {
+    const value = event.time.authoredAt ?? event.time.observedAt ?? null;
+    if (!value)
+        return null;
+    const ms = Date.parse(value);
+    return Number.isFinite(ms) ? ms : null;
+}
+function computeSessionStats(envelope, sessionPath) {
+    const byRole = emptyByRole();
+    const projectionCount = (0, session_events_1.projectedSessionEventIds)(envelope).length;
+    let toolCallTotal = 0;
+    let attachments = 0;
+    const toolNameCounts = new Map();
+    let earliestMs = null;
+    let latestMs = null;
+    for (const event of envelope.events) {
+        byRole[event.role] = (byRole[event.role] ?? 0) + 1;
+        attachments += event.attachments.length;
+        for (const call of event.toolCalls) {
+            toolCallTotal += 1;
+            const name = call.function.name;
+            toolNameCounts.set(name, (toolNameCounts.get(name) ?? 0) + 1);
+        }
+        const ms = eventTimeMs(event);
+        if (ms !== null) {
+            if (earliestMs === null || ms < earliestMs)
+                earliestMs = ms;
+            if (latestMs === null || ms > latestMs)
+                latestMs = ms;
+        }
+    }
+    const top = [...toolNameCounts.entries()]
+        .sort((left, right) => right[1] - left[1])
+        .slice(0, 5)
+        .map(([name, count]) => ({ name, count }));
+    return {
+        sessionPath,
+        envelopeVersion: envelope.version,
+        totalEvents: envelope.events.length,
+        byRole,
+        toolCalls: {
+            total: toolCallTotal,
+            distinctNames: toolNameCounts.size,
+            topByFrequency: top,
+        },
+        attachments,
+        timeRange: {
+            earliest: earliestMs !== null ? new Date(earliestMs).toISOString() : null,
+            latest: latestMs !== null ? new Date(latestMs).toISOString() : null,
+            durationMs: earliestMs !== null && latestMs !== null ? latestMs - earliestMs : null,
+        },
+        projection: {
+            eventCount: projectionCount,
+            omittedFromProjection: Math.max(0, envelope.events.length - projectionCount),
+            inputTokens: envelope.projection.inputTokens,
+            maxTokens: envelope.projection.maxTokens,
+            trimmed: envelope.projection.trimmed,
+        },
+        lastUsage: envelope.lastUsage,
+    };
+}
+function runSessionStats(sessionPath) {
+    const text = fs.readFileSync(sessionPath, "utf-8");
+    const raw = JSON.parse(text);
+    const envelope = (0, session_events_1.parseSessionEnvelope)(raw);
+    if (!envelope) {
+        return {
+            sessionPath,
+            envelopeVersion: null,
+            totalEvents: 0,
+            byRole: emptyByRole(),
+            toolCalls: { total: 0, distinctNames: 0, topByFrequency: [] },
+            attachments: 0,
+            timeRange: { earliest: null, latest: null, durationMs: null },
+            projection: { eventCount: 0, omittedFromProjection: 0, inputTokens: null, maxTokens: null, trimmed: false },
+            lastUsage: null,
+        };
+    }
+    return computeSessionStats(envelope, sessionPath);
+}
+function formatStatsReport(report) {
+    const lines = [];
+    lines.push(`Session stats: ${report.sessionPath}`);
+    if (report.envelopeVersion === null) {
+        lines.push("  envelope: unrecognized (could not parse)");
+        return lines.join("\n");
+    }
+    lines.push(`  envelope version: ${report.envelopeVersion}`);
+    lines.push(`  total events:     ${report.totalEvents}`);
+    lines.push(`  by role:          system=${report.byRole.system} user=${report.byRole.user} assistant=${report.byRole.assistant} tool=${report.byRole.tool}`);
+    lines.push(`  tool calls:       ${report.toolCalls.total} (${report.toolCalls.distinctNames} distinct names)`);
+    if (report.toolCalls.topByFrequency.length > 0) {
+        lines.push("  top tools:");
+        for (const { name, count } of report.toolCalls.topByFrequency) {
+            lines.push(`    ${name}: ${count}`);
+        }
+    }
+    lines.push(`  attachments:      ${report.attachments}`);
+    if (report.timeRange.earliest && report.timeRange.latest) {
+        const durationSec = report.timeRange.durationMs !== null ? Math.round(report.timeRange.durationMs / 1000) : null;
+        lines.push(`  time range:       ${report.timeRange.earliest} → ${report.timeRange.latest}${durationSec !== null ? ` (${durationSec}s)` : ""}`);
+    }
+    lines.push("  projection:");
+    lines.push(`    in projection:  ${report.projection.eventCount}`);
+    lines.push(`    omitted:        ${report.projection.omittedFromProjection}`);
+    if (report.projection.inputTokens !== null)
+        lines.push(`    input tokens:   ${report.projection.inputTokens}`);
+    if (report.projection.maxTokens !== null)
+        lines.push(`    max tokens:     ${report.projection.maxTokens}`);
+    if (report.projection.trimmed)
+        lines.push("    trimmed:        true");
+    if (report.lastUsage) {
+        lines.push(`  last usage:       ${JSON.stringify(report.lastUsage)}`);
+    }
+    return lines.join("\n");
+}
+function runSessionStatsCli(argv) {
+    const positional = argv.filter((token) => !token.startsWith("--"));
+    const flags = new Set(argv.filter((token) => token.startsWith("--")));
+    if (flags.has("--help") || flags.has("-h") || positional.length === 0) {
+        // eslint-disable-next-line no-console -- meta-tooling
+        console.log("usage: ouro session-stats <session.json> [--json]");
+        return positional.length === 0 ? 2 : 0;
+    }
+    const report = runSessionStats(positional[0]);
+    if (flags.has("--json")) {
+        // eslint-disable-next-line no-console -- meta-tooling
+        console.log(JSON.stringify(report, null, 2));
+    }
+    else {
+        // eslint-disable-next-line no-console -- meta-tooling
+        console.log(formatStatsReport(report));
+    }
+    return 0;
+}

package/dist/heart/session-transcript.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.summarizeSessionTail = summarizeSessionTail;
+const runtime_1 = require("../nerves/runtime");
+const session_events_1 = require("./session-events");
+function shouldIncludeToolMessages(friendId, channel) {
+    return friendId === "self" && channel === "inner";
+}
+function sortEventsForTranscript(events) {
+    return [...events].sort((a, b) => {
+        const byTime = Date.parse((0, session_events_1.bestEventTimestamp)(a)) - Date.parse((0, session_events_1.bestEventTimestamp)(b));
+        return byTime === 0 ? a.sequence - b.sequence : byTime;
+    });
+}
+function parseToolArguments(toolCall) {
+    try {
+        const parsed = JSON.parse(toolCall.function.arguments);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function extractHumanVisibleToolText(event, context) {
+    if (event.role !== "assistant" || event.toolCalls.length === 0)
+        return "";
+    for (const toolCall of event.toolCalls) {
+        const args = parseToolArguments(toolCall);
+        if (!args)
+            continue;
+        if (toolCall.function.name === "settle" && typeof args.answer === "string") {
+            return args.answer.trim();
+        }
+        if (toolCall.function.name === "send_message" && typeof args.content === "string") {
+            const targetChannel = typeof args.channel === "string" ? args.channel : "";
+            const targetFriendId = typeof args.friendId === "string" ? args.friendId : "";
+            const targetKey = typeof args.key === "string" ? args.key : "session";
+            if (targetChannel === context.channel && targetFriendId === context.friendId && targetKey === context.key) {
+                return args.content.trim();
+            }
+        }
+    }
+    return "";
+}
+function normalizeSessionMessages(events, context) {
+    return sortEventsForTranscript((0, session_events_1.selectEffectiveSessionEvents)(events))
+        .map((event) => ({
+        id: event.id,
+        role: event.role,
+        content: (0, session_events_1.extractEventText)(event) || extractHumanVisibleToolText(event, context),
+        timestamp: (0, session_events_1.formatSessionEventTimestamp)(event),
+    }))
+        .filter((message) => {
+        if (message.role === "system")
+            return false;
+        if (message.role === "tool" && !context.includeToolMessages)
+            return false;
+        return message.content.length > 0;
+    });
+}
+function buildSummaryInstruction(friendId, channel, trustLevel) {
+    if (friendId === "self" && channel === "inner") {
+        return "summarize this session transcript fully and transparently. this is my own private runtime — include all details, decisions, and reasoning.";
+    }
+    return `summarize this session transcript. the person asking has trust level: ${trustLevel}. family=full transparency, friend=share work and general topics but protect other people's identities, acquaintance=very guarded minimal disclosure.`;
+}
+function clip(text, limit = 160) {
+    const compact = text.replace(/\s+/g, " ").trim();
+    return compact.length > limit ? compact.slice(0, limit - 1) + "…" : compact;
+}
+function buildSnapshot(summary, tailMessages) {
+    const lines = [`recent focus: ${clip(summary, 240)}`];
+    const latestUser = [...tailMessages].reverse().find((message) => message.role === "user").content;
+    const latestAssistant = [...tailMessages].reverse().find((message) => message.role === "assistant")?.content;
+    lines.push(`latest user: ${clip(latestUser)}`);
+    if (latestAssistant) {
+        lines.push(`latest assistant: ${clip(latestAssistant)}`);
+    }
+    return lines.join("\n");
+}
+function selectSessionTailMessages(messages, messageCount) {
+    const requestedCount = Number.isFinite(messageCount) && messageCount > 0 ? Math.floor(messageCount) : 20;
+    const tail = messages.slice(-requestedCount);
+    const selectedIds = new Set(tail.map((message) => message.id));
+    const latestUser = [...messages].reverse().find((message) => message.role === "user");
+    const latestAssistant = [...messages].reverse().find((message) => message.role === "assistant");
+    selectedIds.add(latestUser.id);
+    if (latestAssistant)
+        selectedIds.add(latestAssistant.id);
+    return messages.filter((message) => selectedIds.has(message.id));
+}
+async function summarizeSessionTail(options) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.session_tail_summary",
+        message: "summarizing session transcript tail",
+        meta: {
+            friendId: options.friendId,
+            channel: options.channel,
+            key: options.key,
+            messageCount: options.messageCount,
+        },
+    });
+    const envelope = (0, session_events_1.loadSessionEnvelopeFile)(options.sessionPath);
+    if (!envelope)
+        return { kind: "missing" };
+    const transcriptContext = {
+        friendId: options.friendId,
+        channel: options.channel,
+        key: options.key,
+        includeToolMessages: shouldIncludeToolMessages(options.friendId, options.channel),
+    };
+    const visibleMessages = normalizeSessionMessages(envelope.events, transcriptContext);
+    if (!visibleMessages.some((message) => message.role === "user")) {
+        return { kind: "empty", reason: "envelope_trimmed" };
+    }
+    const tailMessages = selectSessionTailMessages(visibleMessages, options.messageCount);
+    const transcript = tailMessages
+        .map((message) => `[${message.timestamp} | ${message.role} | ${message.id}] ${message.content}`)
+        .join("\n");
+    const summary = options.summarize
+        ? await options.summarize(transcript, buildSummaryInstruction(options.friendId, options.channel, options.trustLevel ?? "family"))
+        : transcript;
+    return {
+        kind: "ok",
+        transcript,
+        summary,
+        snapshot: buildSnapshot(summary, tailMessages),
+        tailMessages,
+    };
+}

package/dist/heart/source-grounding.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXEMPT_WORDS = exports.HOUSE_VOCABULARY = exports.LABEL_WORDS = exports.COMMON_STARTERS = void 0;
+exports.isLookupToolCall = isLookupToolCall;
+exports.mentions = mentions;
+exports.candidateNames = candidateNames;
+exports.lowercaseListNames = lowercaseListNames;
+exports.sourceGroundingFinding = sourceGroundingFinding;
+exports.sourceGroundingError = sourceGroundingError;
+exports.withUnverifiedDisclosure = withUnverifiedDisclosure;
+/**
+ * Primary-source grounding for claims about external works (books, shows, films, their characters).
+ *
+ * A model asked about a work it half-remembers will invent plausible names and present them as fact; a principle in
+ * the prompt did not stop that. This check runs where an answer is about to be delivered and judges the answer against
+ * what the turn actually looked up: a name that appears in no lookup result, and is not house vocabulary or the
+ * person's own words, is a name the model made up. Only a lookup (a web search or page fetch, a catalog lookup, a
+ * curl, the books tool) can clear a name that is claimed to come from a work. Memory, notes, the diary and ordinary
+ * shell output cannot, because they may hold an earlier fabrication. Pure functions; the runtime calls them at settle
+ * for agents that opt in (see ToolContext.answerGates).
+ */
+const runtime_1 = require("../nerves/runtime");
+const LOOKUP_TOOL_NAMES = new Set(["web_search", "media_search", "media_episodes"]);
+const LOOKUP_TOOL_PATTERN = /^(web_fetch|fetch_url|fetch_page|read_url|read_page|browse\w*)$/;
+/** A lookup is a command whose command word is curl or wget, or the books tool; echoing a URL, a here-string or a grep over text is not one. */
+const SHELL_LOOKUP_SEGMENT = /^\s*(?:\w+=\S*\s+)*(?:(?:sudo|env|command|time|nohup)\s+)*(?:(?:curl|wget)\b|books\s+(?:get|search|series|library\s+(?:find|search))\b)/;
+const SHELL_SEGMENT_SEPARATOR = /&&|\|\||[;|\n]/;
+const STRONG_CUE = /\b(books?|novels?|movies?|films?|anime|saga|trilogy|albums?|episodes?|protagonists?)\b/i;
+const WORK_CUE = /\b(books?|novels?|series|saga|trilogy|shows?|movies?|films?|anime|characters?|protagonists?|authors?|episodes?|seasons?|albums?|bands?|lore|cast)\b/i;
+const COPULA_AFTER_NAME = /^(?:['’]s\b|\s+(?:is|was|are|were|isn['’]t|wasn['’]t|has|had|does|did)\b)/i;
+/** Words that start a sentence or a bullet without being a name. */
+exports.COMMON_STARTERS = new Set([
+    "the", "this", "that", "these", "those", "it", "its", "i", "so", "and", "but", "or", "yes", "no", "not", "sure", "okay", "ok", "here", "there",
+    "what", "when", "where", "why", "how", "who", "which", "if", "then", "now", "also", "both", "one", "two", "my", "your", "our", "we", "you", "he", "she", "they",
+    "got", "thanks", "thank", "done", "understood", "noted", "good", "great", "fine", "sorry", "will", "can", "could", "would", "should", "let", "yeah", "yep", "nope",
+    "right", "well", "anyway", "still", "just", "all", "any", "some", "each", "every", "for", "from", "with", "without", "to", "in", "on", "at", "by", "as", "is",
+    "are", "was", "were", "do", "does", "did", "have", "has", "had", "maybe", "probably", "honestly", "unfortunately", "looks", "seems", "see", "check", "try",
+    "use", "make", "keep", "stop", "start", "once", "first", "next", "last", "before", "after", "because", "since", "while", "though", "although", "however",
+    "otherwise", "instead", "meanwhile", "today", "tonight", "tomorrow", "yesterday", "more", "most", "many", "other", "another", "such", "only", "even",
+    "about", "over", "under", "between", "among", "like", "per", "plus", "both", "either", "neither", "whether", "yet", "nothing", "something", "everything",
+    "anything", "everyone", "someone", "anyone", "nobody", "overall", "basically", "actually", "generally", "usually", "often", "sometimes", "never", "always",
+    "note", "tip", "warning", "heads", "update", "summary", "answer", "plan", "status", "result", "results", "source", "sources", "todo",
+]);
+/** A sentence-opening "Word:" is a label when the word is one of these; any other "Name:" is treated as a name. */
+exports.LABEL_WORDS = new Set([
+    "note", "notes", "tip", "warning", "update", "summary", "answer", "plan", "status", "result", "results", "source", "sources", "todo", "next", "why", "how", "what",
+    "done", "reply", "title", "healthy", "snoozed", "down", "up", "broken", "failed", "pending", "running", "stopped", "paused", "queued", "cast", "characters", "authors", "books", "series", "shows", "movies", "episodes", "tldr", "caveat", "caveats", "options", "option",
+]);
+/** Words that read as names but are not about a work: the house, the tools it uses, months, weekdays, common brands and services. */
+exports.HOUSE_VOCABULARY = new Set([
+    "ari", "butler", "claude", "code", "sanctuary", "jellyfin", "sonarr", "radarr", "prowlarr", "jellyseerr", "calibre", "books", "telegram", "unraid", "docker",
+    "mendelow", "cloud", "pocketbook", "astraweb", "usenet", "sabnzbd", "bazarr", "tmdb", "tvdb", "libgen", "plex", "github", "google", "apple", "amazon", "netflix",
+    "hulu", "disney", "youtube", "spotify", "kindle", "kobo", "goodreads", "audible", "python", "javascript", "typescript", "node", "lodash", "vitest", "react",
+    "linux", "windows", "macos", "android", "chrome", "firefox", "safari", "slack", "discord", "wikipedia", "english", "ouro", "ouroboros", "a2a", "radarr", "http", "https",
+    "january", "february", "march", "april", "may", "june", "july", "august", "september", "october", "november", "december",
+    "monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday",
+]);
+/** Status verbs and media nouns that open or fill ordinary replies about media work ("Added the show Silo. Season 1 is grabbing now."): never names, wherever they sit. */
+exports.EXEMPT_WORDS = new Set([
+    "added", "adding", "found", "finding", "sent", "sending", "searching", "searched", "grabbing", "grabbed", "grab", "season", "seasons", "episode", "episodes", "queued", "queueing",
+    "monitoring", "monitored", "imported", "importing", "downloading", "downloaded", "download", "downloads", "requested", "requesting", "removed", "removing", "deleted", "updated", "updating",
+    "checking", "checked", "looking", "looked", "started", "starting", "finished", "finishing", "waiting", "stalled", "retrying", "retried", "marked", "set", "setting", "assigned", "assigning",
+    "movie", "movies", "show", "shows", "book", "books", "series", "film", "films", "less", "tell", "ready", "missing", "available", "unavailable", "specials", "special",
+]);
+/** Contractions are never names: I'll, I'm, They're. */
+const CONTRACTION = /^\p{L}+['’](?:ll|m|re|ve|d|t)$/iu;
+const MIN_NAME_LENGTH = 3;
+const MAX_ACRONYM_LENGTH = 5;
+const LOWERCASE_LIST_INTRO = /\b(?:characters?|cast|names?|authors?|protagonists?|bands?|members?)\b[ \t]*(?::|—|-|are|includes?|including|like|such as)[ \t]+([^.!?\n]+)/gi;
+const LOWERCASE_LIST_ITEM = /^[a-z][a-z'’-]{3,}$/;
+const LOWERCASE_LIST_STOP = new Set(["others", "etc", "more", "many", "several", "various", "everyone", "anyone", "someone", "people", "these", "those", "them", "others", "similar", "same", "like"]);
+/** True when the call read a primary source: a web search or page fetch, a catalog lookup, a curl, or the books tool. */
+function isLookupToolCall(record) {
+    if (LOOKUP_TOOL_NAMES.has(record.name) || LOOKUP_TOOL_PATTERN.test(record.name))
+        return true;
+    return record.name === "shell" && (record.args.command ?? "").split(SHELL_SEGMENT_SEPARATOR).some((segment) => SHELL_LOOKUP_SEGMENT.test(segment));
+}
+const escapeRegExp = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/** Whole-word, case-insensitive, Unicode-aware: "Dross" is not found inside "Drossel" or "Gross". */
+function mentions(haystack, name) {
+    return new RegExp(`(?<![\\p{L}\\p{N}])${escapeRegExp(name)}(?![\\p{L}\\p{N}])`, "iu").test(haystack);
+}
+const TOKEN = /\p{Lu}[\p{L}\p{M}'’]*/gu;
+/** Capitalised words that read as names, in order of first appearance, case-insensitively de-duplicated. House vocabulary is not a name. */
+function candidateNames(text) {
+    const seen = new Set();
+    const names = [];
+    for (const match of text.matchAll(TOKEN)) {
+        const word = match[0].replace(/['’]s$/i, "").replace(/['’]$/, "");
+        if (word.length < MIN_NAME_LENGTH)
+            continue;
+        if (word.length <= MAX_ACRONYM_LENGTH && word === word.toUpperCase())
+            continue;
+        const lower = word.toLowerCase();
+        if (lower === "the" || CONTRACTION.test(word) || exports.HOUSE_VOCABULARY.has(lower) || exports.EXEMPT_WORDS.has(lower) || seen.has(lower))
+            continue;
+        const before = text.slice(0, match.index).replace(/[ \t"'“‘(\[*_#>-]+$/u, "");
+        const startsSentence = before === "" || /[.!?:\n]$/.test(before);
+        const after = text.slice(match.index + match[0].length);
+        if (startsSentence && exports.COMMON_STARTERS.has(lower))
+            continue;
+        if (startsSentence && exports.LABEL_WORDS.has(lower) && after.startsWith(":"))
+            continue;
+        if (startsSentence && !startsLikeName(text, match.index, after, lower))
+            continue;
+        seen.add(lower);
+        names.push(word);
+    }
+    return names;
+}
+/**
+ * An ordinary sentence opens with a capital whether or not the word is a name ("Silo is in Sonarr", "Remember to..."). A sentence-opening word
+ * therefore counts as a name only with a sign it is one: it is capitalised elsewhere mid-sentence, it sits in a quote or emphasis or opens a bullet,
+ * it is followed by a colon, a copula, or a list continuation ("Lindon and Yerin").
+ */
+function startsLikeName(text, index, after, lower) {
+    const rawBefore = index > 0 ? text[index - 1] : "";
+    if (/["“‘'*_]/.test(rawBefore))
+        return true;
+    const line = text.slice(text.lastIndexOf("\n", index - 1) + 1, index);
+    if (/^\s*(?:[-*•>]|\d+[.)])\s+$/.test(line))
+        return true;
+    if (after.startsWith(":") || COPULA_AFTER_NAME.test(after) || /^(?:,|\s+and|\s*&)\s*\p{Lu}/u.test(after))
+        return true;
+    return midSentenceCapitalised(text, lower);
+}
+function midSentenceCapitalised(text, lower) {
+    for (const match of text.matchAll(TOKEN)) {
+        const word = match[0].replace(/['’]s$/i, "").replace(/['’]$/, "");
+        if (word.toLowerCase() !== lower)
+            continue;
+        const before = text.slice(0, match.index).replace(/[ \t"'“‘(\[*_#>-]+$/u, "");
+        if (!(before === "" || /[.!?:\n]$/.test(before)))
+            return true;
+    }
+    return false;
+}
+/** Lowercase items in a list a work cue introduces ("characters: lindon, yerin and eithan"): two or more are treated as names. */
+function lowercaseListNames(text) {
+    const names = [];
+    for (const intro of text.matchAll(LOWERCASE_LIST_INTRO)) {
+        const items = intro[1].split(/,|;|\band\b|\bor\b/i).map((item) => item.trim().split(/\s+/).slice(0, 2).join(" ")).map((item) => (/\s/.test(item) ? item.split(" ")[0] : item));
+        const words = items.filter((item) => LOWERCASE_LIST_ITEM.test(item) && !exports.COMMON_STARTERS.has(item) && !LOWERCASE_LIST_STOP.has(item) && !exports.HOUSE_VOCABULARY.has(item));
+        if (words.length >= 2)
+            names.push(...words);
+    }
+    return [...new Set(names)];
+}
+function claimsSomethingAbout(answer, name) {
+    const lower = answer.toLowerCase();
+    const needle = name.toLowerCase();
+    for (let at = lower.indexOf(needle); at !== -1; at = lower.indexOf(needle, at + needle.length)) {
+        if (COPULA_AFTER_NAME.test(answer.slice(at + needle.length)))
+            return true;
+    }
+    return false;
+}
+/**
+ * What is wrong with a reply about an external work, or null: it names things no lookup this turn contains (invented),
+ * or states something about a work the person only named, with no lookup at all (unsourced_claim).
+ */
+function sourceGroundingFinding(input) {
+    if (!WORK_CUE.test(input.answer))
+        return null;
+    const lookups = input.tools.filter(isLookupToolCall);
+    const lookedUp = lookups.map((record) => record.result).join("\n");
+    const names = [...candidateNames(input.answer), ...lowercaseListNames(input.answer)];
+    const invented = names.filter((name) => !mentions(lookedUp, name) && !mentions(input.userText, name));
+    if (invented.length > 0 && (invented.length >= 2 || STRONG_CUE.test(input.answer))) {
+        const named = invented.join(", ");
+        (0, runtime_1.emitNervesEvent)({ level: "warn", component: "engine", event: "engine.unsourced_work_claim", message: "a reply named things from a work that the turn did not look up", meta: { names: invented.length, lookups: lookups.length } });
+        return {
+            kind: "invented", names: invented, lookups: lookups.length,
+            message: lookups.length === 0
+                ? `you named ${named} as part of a book, show, film or its cast, and you looked up nothing this turn. don't state facts about a work from memory. read a primary source first (web_search, or fetch the page), then answer only from what it says. if you can't find it, say so plainly.`
+                : `${named} do not appear in anything you looked up this turn, so they may be made up. check them against the source you read, drop the ones it does not support, or look them up, then settle again.`,
+        };
+    }
+    const unsourced = names.filter((name) => mentions(input.userText, name) && !mentions(lookedUp, name) && claimsSomethingAbout(input.answer, name));
+    if (lookups.length === 0 && unsourced.length > 0) {
+        return {
+            kind: "unsourced_claim", names: unsourced, lookups: 0,
+            message: `you stated something about ${unsourced.join(", ")} and looked up nothing this turn. read a primary source first (web_search, or fetch the page), then answer only from what it says. if you can't find it, say so plainly.`,
+        };
+    }
+    return null;
+}
+function sourceGroundingError(input) {
+    return sourceGroundingFinding(input)?.message ?? null;
+}
+/** When the model keeps naming unsourced things after the retries are spent, say so rather than deliver them as fact. */
+function withUnverifiedDisclosure(answer, names) {
+    return `I couldn't verify ${names.join(", ")} against a source, so treat ${names.length === 1 ? "that" : "those"} as unconfirmed.\n\n${answer}`;
+}