@linxiraos/pi-stats 1.3.2 → 1.4.0

package/src/model-metrics.ts

@@ -0,0 +1,153 @@
+/**
+ * Behavioral metrics extracted from a single assistant message: the model-side
+ * counterpart of `user-metrics.ts`.
+ *
+ * The dashboard calls this "AI breakdown level" (AI 崩溃度): how often a model's
+ * replies show the textual marks of a turn that is going badly. Every signal
+ * is a count, so the dashboard can report a share of turns that carry it:
+ *
+ * - `selfBlame` — apologies and admissions ("I'm sorry", "my mistake", "是我搞错了")
+ * - `restatement` — "as I said earlier", "to reiterate", "如前所述", plus
+ *   near-duplicate repetition of the previous assistant prose (language-neutral)
+ * - `hedge` — hedged fallbacks ("I'm not sure", "you could also try", "仅供参考")
+ * - `verbose` — 1 when the turn runs past {@link VERBOSE_WORD_THRESHOLD} words
+ * - `toolSpiral` — 1 when the turn follows {@link TOOL_SPIRAL_THRESHOLD}+ failed
+ *   tool results (the parser counts `toolResult.isError`, the same flag
+ *   `tool_calls.is_error` stores)
+ * - `collapse` — the per-turn aggregate: the marker counts plus failed tool
+ *   results (capped), so one turn with one marker scores 1
+ *
+ * Lexicons are summed together, never chosen by detected language: a mixed
+ * Chinese/English reply, or one written in a language a recognizer mislabels,
+ * must not silently lose half its markers. Code fences, XML wrappers, URLs and
+ * inline code are stripped by {@link analysisProse} before scoring, so a
+ * model quoting a failing test or a config file does not look broken.
+ *
+ * Pure and side-effect free, like the user analyzer.
+ */
+import { countMatches, detectRepeatedMessage, detectUnsupportedScript, WORD_RE } from "./user-metrics";
+
+export interface AssistantMessageMetrics {
+	/** Characters of analyzed prose (code and markup stripped, capped). */
+	chars: number;
+	/** Whitespace-delimited words of analyzed prose. */
+	words: number;
+	/** Apology / self-blame markers. */
+	selfBlame: number;
+	/** Repeated-restatement markers plus near-duplicate previous turn. */
+	restatement: number;
+	/** Hedged fallback markers. */
+	hedge: number;
+	/** 1 when the turn is long-winded (see {@link VERBOSE_WORD_THRESHOLD}). */
+	verbose: number;
+	/** Failed tool results preceding this turn, as counted at ingest. */
+	toolErrors: number;
+	/** 1 when {@link toolErrors} reaches {@link TOOL_SPIRAL_THRESHOLD}. */
+	toolSpiral: number;
+	/** Per-turn aggregate (see the module docs). */
+	collapse: number;
+	/** 1 when the prose leans on a script no lexicon covers; such rows are unscored, not calm. */
+	unsupportedScript: number;
+}
+
+/**
+ * Words past which a reply counts as long-winded. Coding-agent answers usually
+ * land well under this; a 400-word turn is the point where the model is
+ * explaining at the user instead of answering.
+ */
+export const VERBOSE_WORD_THRESHOLD = 400;
+
+/**
+ * Character floor for the same signal. Chinese prose has no spaces, so
+ * `WORD_RE` sees one "word" per line; roughly 1.5 characters per word makes
+ * this the equivalent of {@link VERBOSE_WORD_THRESHOLD}.
+ */
+export const VERBOSE_CHAR_THRESHOLD = 2_400;
+
+/** Consecutive failed tool results that make a turn part of a failure spiral. */
+export const TOOL_SPIRAL_THRESHOLD = 3;
+
+/** Failed tool results beyond this many add no further weight to `collapse`. */
+export const TOOL_ERROR_COLLAPSE_CAP = 10;
+
+// Apologies and admissions, English and Chinese. `apologies` stands alone;
+// "I'm afraid" is hedged uncertainty and lives in HEDGE_RE instead.
+const SELF_BLAME_RE =
+	/(?:\bi(?:'m| am) (?:so |really |very )?sorry\b|\bmy (?:apologies|bad|mistake|fault)\b|\bi apologi[sz]e\b|\bapologies\b|\bi was (?:wrong|mistaken)\b|\bi made (?:a|an|the) (?:mistake|error|bug)\b|\bi(?:'ve| have) (?:made|introduced) (?:a|an|the) (?:mistake|error|bug)\b|\bthat(?:'s| is| was) my (?:mistake|fault|error)\b|\bi stand corrected\b|\bsorry (?:about|for) (?:that|this|the confusion)\b)/gi;
+const ZH_SELF_BLAME_RE =
+	/(?:抱歉|对不起|不好意思|是我(?:的)?错|我错了|我搞错(?:了)?|我弄错(?:了)?|是我疏忽|我疏忽了|我犯(?:了)?错|实在抱歉|非常抱歉|请原谅)/g;
+
+// Explicit restatement. Bare "again" / "repeating" are far too common in
+// technical prose ("repeating pattern") to count on their own.
+const RESTATEMENT_RE =
+	/(?:\bas i (?:said|mentioned|noted) (?:earlier|before|above)\b|\bas (?:previously|mentioned|noted) (?:above|earlier)\b|\bto reiterate\b|\bto restate\b|\blet me (?:repeat|restate|clarify)\b|\bin other words\b|\bonce again\b|\bas noted (?:above|earlier)\b|\blike i said\b|\bto repeat\b)/gi;
+const ZH_RESTATEMENT_RE =
+	/(?:再说一遍|再说一次|重复一遍|重复一次|如前所述|正如(?:我)?(?:之前|前面)(?:所说|提到)|我(?:已经)?说过|再次(?:说明|强调)|换句话(?:说)?|重申)/g;
+
+// Uncertainty and work-avoiding fallbacks. Deliberately excludes bare
+// "I think" / "maybe", which are ordinary model prose and would swamp the
+// signal; only explicit inability or deferral counts.
+const HEDGE_RE =
+	/(?:\bi(?:'m| am) (?:not (?:entirely |completely |100% )?sure|unsure|not certain)\b|\bnot 100% sure\b|\bit depends\b|\bas far as i can tell\b|\bif that helps\b|\blet me know if\b|\byou could also\b|\balternatively, you could\b|\bone option is\b|\bin theory\b|\bi can(?:no|')?t (?:be sure|guarantee|promise)\b|\bi(?:'m| am) afraid\b|\bhopefully\b)/gi;
+const ZH_HEDGE_RE =
+	/(?:我不(?:太)?确定|不太确定|不确定|可能|也许|或许|应该(?:可以|能|没问题)|大概(?:是|可以|能)?|你可以(?:试试|尝试)|可以试试|试试看|仅供参考|如果(?:还)?不行|希望(?:这|对你)?(?:有)?(?:所)?帮助|不太好说|说不准)/g;
+
+/** Empty metrics constant for callers that need a default. */
+export const EMPTY_ASSISTANT_METRICS: AssistantMessageMetrics = Object.freeze({
+	chars: 0,
+	words: 0,
+	selfBlame: 0,
+	restatement: 0,
+	hedge: 0,
+	verbose: 0,
+	toolErrors: 0,
+	toolSpiral: 0,
+	collapse: 0,
+	unsupportedScript: 0,
+});
+
+/**
+ * Compute behavioral metrics for one assistant turn.
+ *
+ * `text` is the turn's analysis prose (see {@link analysisProse}) — the parser
+ * strips thinking blocks and structured content before calling this. Empty or
+ * whitespace-only input returns zeros.
+ */
+export function computeAssistantMessageMetrics(
+	text: string,
+	options: {
+		/** The previous prose-bearing assistant turn in the same session, for restatement. */
+		prevText?: string;
+		/** Failed tool results since the previous assistant turn. */
+		toolErrors?: number;
+	} = {},
+): AssistantMessageMetrics {
+	const trimmed = text.trim();
+	const toolErrors = Math.max(0, Math.trunc(options.toolErrors ?? 0));
+	if (!trimmed)
+		return { ...EMPTY_ASSISTANT_METRICS, toolErrors, toolSpiral: toolErrors >= TOOL_SPIRAL_THRESHOLD ? 1 : 0 };
+
+	const words = countMatches(trimmed, WORD_RE);
+	const selfBlame = countMatches(trimmed, SELF_BLAME_RE) + countMatches(trimmed, ZH_SELF_BLAME_RE);
+	const restatement =
+		countMatches(trimmed, RESTATEMENT_RE) +
+		countMatches(trimmed, ZH_RESTATEMENT_RE) +
+		detectRepeatedMessage(trimmed, options.prevText ?? "");
+	const hedge = countMatches(trimmed, HEDGE_RE) + countMatches(trimmed, ZH_HEDGE_RE);
+	const verbose = words >= VERBOSE_WORD_THRESHOLD || trimmed.length >= VERBOSE_CHAR_THRESHOLD ? 1 : 0;
+	const toolSpiral = toolErrors >= TOOL_SPIRAL_THRESHOLD ? 1 : 0;
+	const toolPenalty = toolSpiral === 1 ? Math.min(toolErrors, TOOL_ERROR_COLLAPSE_CAP) : 0;
+
+	return {
+		chars: trimmed.length,
+		words,
+		selfBlame,
+		restatement,
+		hedge,
+		verbose,
+		toolErrors,
+		toolSpiral,
+		collapse: selfBlame + restatement + hedge + verbose + toolPenalty,
+		unsupportedScript: detectUnsupportedScript(trimmed),
+	};
+}

package/src/model-side.ts

@@ -0,0 +1,77 @@
+/**
+ * Model-side dashboard: how often each model's own replies show the textual
+ * marks of a turn going badly ("AI breakdown level", AI 崩溃度).
+ *
+ * The signals are computed at ingest (`model-metrics.ts`) and stored in
+ * `assistant_text`; this module merges them by catalog identity and shapes the
+ * payload for the frustration page's second section. It never judges anything:
+ * there is no model call and no extra storage beyond the capped prose row.
+ */
+import { getTimeRangeConfig } from "./aggregator";
+import {
+	getModelSideByModel,
+	getModelSideBySession,
+	getModelSideOverall,
+	getModelSideTimeSeries,
+	initDb,
+	type ModelSideModelRow,
+} from "./db";
+import { compareModelIdentity, modelIdentityOf } from "./model-identity";
+import type { ModelSideDashboardStats, ModelSideModelStats } from "./shared-types";
+
+/** Sessions the payload carries. The long tail is available only through the DB. */
+const SESSION_LIMIT = 40;
+
+/** Merge per-(model, provider) rows into catalog identities, same grouping as the user side. */
+export function mergeModelSideRows(rows: readonly ModelSideModelRow[]): ModelSideModelStats[] {
+	const merged = new Map<string, ModelSideModelStats>();
+	for (const row of rows) {
+		const identity = modelIdentityOf(row.provider, row.model);
+		const existing = merged.get(identity.key);
+		if (existing) {
+			existing.messages += row.messages;
+			existing.blamed += row.blamed;
+			existing.restated += row.restated;
+			existing.hedged += row.hedged;
+			existing.verbose += row.verbose;
+			existing.spiraled += row.spiraled;
+			existing.breakdown += row.breakdown;
+			existing.collapse += row.collapse;
+			existing.words += row.words;
+			existing.toolErrors += row.toolErrors;
+			existing.unscored += row.unscored;
+			existing.firstSeen = Math.min(existing.firstSeen, row.firstSeen);
+			if (!existing.models.includes(row.model)) existing.models.push(row.model);
+			continue;
+		}
+		merged.set(identity.key, {
+			...identity,
+			models: [row.model],
+			firstSeen: row.firstSeen,
+			messages: row.messages,
+			blamed: row.blamed,
+			restated: row.restated,
+			hedged: row.hedged,
+			verbose: row.verbose,
+			spiraled: row.spiraled,
+			breakdown: row.breakdown,
+			collapse: row.collapse,
+			words: row.words,
+			toolErrors: row.toolErrors,
+			unscored: row.unscored,
+		});
+	}
+	return [...merged.values()].sort(compareModelIdentity);
+}
+
+/** Model-side section of `GET /api/stats/frustration`. */
+export async function getModelSideDashboardStats(range?: string | null): Promise<ModelSideDashboardStats> {
+	await initDb();
+	const { cutoff, bucketMs } = getTimeRangeConfig(range);
+	return {
+		overall: getModelSideOverall(cutoff),
+		byModel: mergeModelSideRows(getModelSideByModel(cutoff)),
+		series: getModelSideTimeSeries({ cutoff, bucketMs }),
+		bySession: getModelSideBySession(cutoff, SESSION_LIMIT),
+	};
+}

package/src/parser.ts

@@ -16,6 +16,7 @@ import { classifyModel } from "@linxiraos/pi-catalog/compat/taxonomy";
 import { getSessionsDir, isEnoent, readLines } from "@linxiraos/pi-utils";
 import type {
 	AgentType,
+	AssistantTextStats,
 	MessageStatsInput,
 	SessionEntry,
 	SessionMessageEntry,
@@ -26,7 +27,8 @@ import type {
 	UserMessageLink,
 	UserMessageStats,
 } from "./types";
-import { computeUserMessageMetrics, judgeProse } from "./user-metrics";
+import { computeAssistantMessageMetrics } from "./model-metrics";
+import { analysisProse, computeUserMessageMetrics } from "./user-metrics";
 
 /** Basename of an advisor agent's transcript inside a session artifacts dir. */
 const ADVISOR_TRANSCRIPT_BASENAME = "__advisor.jsonl";
@@ -112,21 +114,30 @@ function isToolResultMessage(entry: SessionEntry): entry is SessionMessageEntry
 }
 
 /**
- * Extract plain text from a user message content payload.
+ * Concatenate the `text` content blocks of a message payload, skipping every
+ * other block type (thinking/reasoning, tool calls, tool results, images).
  */
-function extractUserText(content: unknown): string {
-	if (typeof content === "string") return content;
+function extractTextBlocks(content: unknown): string {
 	if (!Array.isArray(content)) return "";
 	const parts: string[] = [];
 	for (const block of content) {
-		if (block && typeof block === "object" && (block as { type?: unknown }).type === "text") {
-			const text = (block as { text?: unknown }).text;
-			if (typeof text === "string") parts.push(text);
-		}
+		if (!block || typeof block !== "object" || !("type" in block)) continue;
+		const type = block.type;
+		if (type !== "text" || !("text" in block)) continue;
+		const text = block.text;
+		if (typeof text === "string") parts.push(text);
 	}
 	return parts.join("");
 }
 
+/**
+ * Extract plain text from a user message content payload.
+ */
+function extractUserText(content: unknown): string {
+	if (typeof content === "string") return content;
+	return extractTextBlocks(content);
+}
+
 /**
  * Build user-message stats from an entry. Returns null for empty/synthetic content.
  */
@@ -141,7 +152,7 @@ function extractUserStats(
 	const text = extractUserText(msg.content);
 	if (!text.trim()) return null;
 	const metrics = computeUserMessageMetrics(text, { prevText });
-	const prose = judgeProse(text);
+	const prose = analysisProse(text);
 	const ts = Date.parse(entry.timestamp);
 	return {
 		sessionFile,
@@ -165,6 +176,53 @@ function extractUserStats(
 	};
 }
 
+/**
+ * Build the model-side analysis row for an assistant turn. Only `text` blocks
+ * are read: thinking/reasoning blocks are the model's scratchpad, not what it
+ * said to the user (see {@link extractTextBlocks}). Returns null for turns
+ * without text or without an attributable model/provider: a tool-call-only
+ * reply has nothing to analyze, and an unattributable turn cannot join a
+ * per-model aggregate.
+ */
+function extractAssistantTextStats(
+	sessionFile: string,
+	folder: string,
+	entry: SessionMessageEntry,
+	agentType: AgentType,
+	prevProse: string,
+	toolErrors: number,
+): AssistantTextStats | null {
+	const msg = entry.message as AssistantMessage;
+	if (msg?.role !== "assistant") return null;
+	if (typeof msg.model !== "string" || typeof msg.provider !== "string") return null;
+	const text = extractTextBlocks(msg.content);
+	if (!text.trim()) return null;
+	const prose = analysisProse(text);
+	// A reply that was nothing but code/markup has no analysis body to store.
+	if (!prose) return null;
+	const metrics = computeAssistantMessageMetrics(prose, { prevText: prevProse, toolErrors });
+	return {
+		sessionFile,
+		entryId: entry.id,
+		folder,
+		timestamp: coerceEntryTimestamp(msg.timestamp, entry),
+		model: msg.model,
+		provider: msg.provider,
+		agentType,
+		chars: metrics.chars,
+		words: metrics.words,
+		selfBlame: metrics.selfBlame,
+		restatement: metrics.restatement,
+		hedge: metrics.hedge,
+		verbose: metrics.verbose,
+		toolErrors: metrics.toolErrors,
+		toolSpiral: metrics.toolSpiral,
+		collapse: metrics.collapse,
+		unsupportedScript: metrics.unsupportedScript,
+		prose,
+	};
+}
+
 /**
  * Session JSONL is written by older versions and foreign producers, so a token
  * counter is whatever was persisted, not what `Usage` declares. A non-numeric
@@ -512,6 +570,7 @@ export interface SessionParserState {
 export interface ParseSessionResult {
 	stats: MessageStatsInput[];
 	userStats: UserMessageStats[];
+	assistantTexts: AssistantTextStats[];
 	userLinks: UserMessageLink[];
 	toolCalls: ToolCallStats[];
 	toolResults: ToolResultLink[];
@@ -557,6 +616,7 @@ export async function parseSessionFile(
 	const agentType = classifyAgentType(sessionPath);
 	const stats: MessageStatsInput[] = [];
 	const userStats: UserMessageStats[] = [];
+	const assistantTexts: AssistantTextStats[] = [];
 	const userLinks: UserMessageLink[] = [];
 	const toolCalls: ToolCallStats[] = [];
 	const toolResults: ToolResultLink[] = [];
@@ -565,6 +625,13 @@ export async function parseSessionFile(
 	// incremental parse starts mid-session, so the first message of a resumed
 	// pass simply carries no predecessor.
 	let prevUserText = "";
+	// Model-side analysis: the previous prose-bearing assistant turn (for
+	// repeated restatement) and the failed tool results since the last
+	// assistant turn (for tool-failure spirals). Both start empty on a resumed
+	// tail read: the first assistant turn of that pass carries no predecessor
+	// and no spiral count, and the next full re-parse fills them in.
+	let prevAssistantText = "";
+	let pendingToolErrors = 0;
 
 	// Reduce each entry immediately so full replays do not retain tool-output/message bodies.
 	const visit = (entry: SessionEntry): void => {
@@ -582,7 +649,10 @@ export async function parseSessionFile(
 		}
 		if (isToolResultMessage(entry)) {
 			const link = extractToolResultLink(sessionPath, entry);
-			if (link) toolResults.push(link);
+			if (link) {
+				toolResults.push(link);
+				if (link.isError) pendingToolErrors++;
+			}
 			return;
 		}
 		if (isModelUsage(entry)) {
@@ -594,6 +664,20 @@ export async function parseSessionFile(
 			const msgStats = extractStats(sessionPath, folder, entry, currentServiceTier, agentType);
 			if (msgStats) stats.push(msgStats);
 			toolCalls.push(...extractToolCalls(sessionPath, folder, entry, agentType));
+			const textStats = extractAssistantTextStats(
+				sessionPath,
+				folder,
+				entry,
+				agentType,
+				prevAssistantText,
+				pendingToolErrors,
+			);
+			if (textStats) {
+				assistantTexts.push(textStats);
+				prevAssistantText = textStats.prose;
+			}
+			// The next assistant turn starts a fresh failure chain.
+			pendingToolErrors = 0;
 			// Persist links even when the user entry was ingested in an earlier tail read.
 			const parentId = entry.parentId;
 			const msg = entry.message;
@@ -646,7 +730,15 @@ export async function parseSessionFile(
 		}
 	} catch (err) {
 		if (isEnoent(err))
-			return { stats: [], userStats: [], userLinks: [], toolCalls: [], toolResults: [], newOffset: fromOffset };
+			return {
+				stats: [],
+				userStats: [],
+				assistantTexts: [],
+				userLinks: [],
+				toolCalls: [],
+				toolResults: [],
+				newOffset: fromOffset,
+			};
 		throw err;
 	}
 
@@ -654,6 +746,7 @@ export async function parseSessionFile(
 	return {
 		stats,
 		userStats,
+		assistantTexts,
 		userLinks,
 		toolCalls,
 		toolResults,

package/src/shared-types.ts

@@ -193,6 +193,97 @@ export interface AgentTypeStats {
 	totalCost: number;
 }
 
+/**
+ * Model-side tallies over assistant turns. Every field except `messages`,
+ * `collapse`, `words` and `toolErrors` counts turns carrying the signal, so
+ * `blamed / messages` is a share. `collapse` and `words` are sums: their means
+ * are `collapse / messages` and `words / messages`.
+ *
+ * Coverage is textual: only turns that produced prose are analyzed, so
+ * tool-call-only replies and thinking blocks are outside the denominator.
+ * `unscored` counts turns whose prose leans on a script no lexicon covers -
+ * their zero signal counts mean "unscored", not "calm".
+ */
+export interface ModelSideCounts {
+	/** Assistant turns with stored prose. */
+	messages: number;
+	/** Turns with an apology or admission. */
+	blamed: number;
+	/** Turns restating earlier content. */
+	restated: number;
+	/** Turns with a hedged fallback. */
+	hedged: number;
+	/** Turns past the verbosity threshold. */
+	verbose: number;
+	/** Turns following a tool-failure spiral. */
+	spiraled: number;
+	/** Turns with a non-zero per-turn aggregate. */
+	breakdown: number;
+	/** Sum of per-turn aggregate values. */
+	collapse: number;
+	/** Sum of analyzed words. */
+	words: number;
+	/** Sum of failed tool results preceding the turns. */
+	toolErrors: number;
+	/** Turns in a script no lexicon covers. */
+	unscored: number;
+}
+
+/** Model-side tallies for one model version, merged by catalog identity. */
+export interface ModelSideModelStats extends ModelSideCounts {
+	/** Stable key: `class/family/revision` when classified, else the raw model id. */
+	key: string;
+	/** Display label, e.g. `opus 4.5`; the raw model id when unclassified. */
+	label: string;
+	/** Catalog identity class, e.g. `anthropic`; `unknown` when unclassified. */
+	modelClass: string;
+	/** Catalog family within the class, e.g. `opus`. */
+	family: string | null;
+	/** Canonical `major.minor.patch`, e.g. `4.5.0`. */
+	revision: string | null;
+	/** Raw model ids merged into this row. */
+	models: string[];
+	/** Earliest turn timestamp (ms) in range. */
+	firstSeen: number;
+}
+
+/** One bucket of the model-side time series. */
+export interface ModelSideTimeSeriesPoint {
+	/** Bucket start (Unix ms). */
+	timestamp: number;
+	messages: number;
+	breakdown: number;
+	blamed: number;
+	restated: number;
+	hedged: number;
+	spiraled: number;
+	collapse: number;
+}
+
+/** Model-side tallies for one session, busiest first in the dashboard payload. */
+export interface ModelSideSessionStats extends ModelSideCounts {
+	/** Absolute transcript path. */
+	sessionFile: string;
+	/** Project folder the transcript belongs to. */
+	folder: string;
+	/** Distinct model ids in the session. */
+	models: string[];
+	/** Earliest and latest analyzed turn (ms). */
+	firstSeen: number;
+	lastSeen: number;
+}
+
+/** Payload of the model-side section of `GET /api/stats/frustration`. */
+export interface ModelSideDashboardStats {
+	overall: ModelSideCounts;
+	/** Every model with analyzed turns in range. */
+	byModel: ModelSideModelStats[];
+	/** Bucketed trend over the active range. */
+	series: ModelSideTimeSeriesPoint[];
+	/** Sessions with the most analyzed turns, capped for payload size. */
+	bySession: ModelSideSessionStats[];
+}
+
 /**
  * Frustration tallies over a set of user messages. Each message counts once,
  * classified by its cached judge verdict when one exists, else by the regex
@@ -269,6 +360,8 @@ export interface FrustrationDashboardStats {
 	overall: FrustrationCounts;
 	/** Every model with messages in range, ordered by class, then revision, then family. */
 	byModel: FrustrationModelStats[];
+	/** Model-side (AI breakdown) analysis alongside the user-side tallies. */
+	modelSide: ModelSideDashboardStats;
 	/** Whether this dashboard host can run the judge (standalone `omp-stats` cannot). */
 	judgeAvailable: boolean;
 	job: FrustrationJobStatus;

package/src/types.ts

@@ -187,12 +187,59 @@ export interface UserMessageStats {
 	emphasis: number;
 	/** 1 when the prose leans on a script no lexicon covers; such rows are unscored, not calm. */
 	unsupportedScript: number;
-	/** Judge-facing prose (see `judgeProse`); empty when the message was all markup. */
+	/** Judge-facing prose (see `analysisProse`); empty when the message was all markup. */
 	prose: string;
 	/** Hex `Bun.hash` of `prose`, keying the shared verdict cache; empty when `prose` is. */
 	proseHash: string;
 }
 
+/**
+ * Model-side analysis for one assistant turn: the text body stored for
+ * offline analysis plus the signals computed from it at ingest (see
+ * `model-metrics.ts`). Keyed like `user_messages` by (session_file, entry_id).
+ * Turns without prose (tool-call-only replies) emit no row.
+ */
+export interface AssistantTextStats {
+	/** Database ID */
+	id?: number;
+	/** Session file path */
+	sessionFile: string;
+	/** Assistant message entry ID within the session */
+	entryId: string;
+	/** Folder/project path (extracted from session filename) */
+	folder: string;
+	/** Unix timestamp in ms */
+	timestamp: number;
+	/** Model that produced the turn */
+	model: string;
+	/** Provider that served the turn */
+	provider: string;
+	/** Which agent produced the turn (main agent, task subagent, advisor) */
+	agentType: AgentType;
+	/** Analyzed-prose characters (code and markup stripped, capped) */
+	chars: number;
+	/** Analyzed-prose words */
+	words: number;
+	/** Apology / self-blame markers */
+	selfBlame: number;
+	/** Repeated-restatement markers plus near-duplicate previous turn */
+	restatement: number;
+	/** Hedged fallback markers */
+	hedge: number;
+	/** 1 when the turn is long-winded */
+	verbose: number;
+	/** Failed tool results preceding the turn */
+	toolErrors: number;
+	/** 1 when the preceding failures form a spiral */
+	toolSpiral: number;
+	/** Per-turn aggregate (see `AssistantMessageMetrics`) */
+	collapse: number;
+	/** 1 when the prose leans on a script no lexicon covers */
+	unsupportedScript: number;
+	/** Stored analysis prose (see `analysisProse`); never empty for an emitted row. */
+	prose: string;
+}
+
 /**
  * Pair emitted by the parser when it sees an assistant message whose
  * `parentId` points to a user message that wasn't parsed in the same pass

package/src/user-metrics.ts

@@ -460,7 +460,7 @@ const YELLING_THRESHOLD = 0.5;
 // classic shift-key mishit ("!!!111" / "!?!??111") so we count those as
 // part of the same drama burst.
 const DRAMA_RE = /[!?][!?1]{2,}/g;
-const WORD_RE = /\S+/g;
+export const WORD_RE = /\S+/g;
 
 // Anguish/exasperation interjections. Each alternative is a case-insensitive
 // word-bounded pattern. Interjections whose short form collides with normal
@@ -664,7 +664,7 @@ const UNSUPPORTED_SCRIPT_RE =
 const UNSUPPORTED_SCRIPT_SHARE = 0.3;
 
 /** 1 when the prose leans on a script the lexicons do not cover. */
-function detectUnsupportedScript(prose: string): number {
+export function detectUnsupportedScript(prose: string): number {
 	const letters = countMatches(prose, SCRIPT_LETTER_RE);
 	if (letters < 4) return 0;
 	return countMatches(prose, UNSUPPORTED_SCRIPT_RE) / letters > UNSUPPORTED_SCRIPT_SHARE ? 1 : 0;
@@ -689,7 +689,7 @@ function bigrams(normalized: string): Set<string> {
  * the one frustration signal that needs no lexicon and therefore works for
  * any language and survives every transcription error.
  */
-function detectRepeatedMessage(prose: string, prevProse: string): number {
+export function detectRepeatedMessage(prose: string, prevProse: string): number {
 	const current = normalizeForComparison(prose);
 	const previous = normalizeForComparison(prevProse);
 	if (current.length < REPEATED_MESSAGE_MIN_CHARS || previous.length < REPEATED_MESSAGE_MIN_CHARS) return 0;
@@ -731,7 +731,7 @@ const ANSI_ESCAPE_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
 const MAX_PROSE_LINES = 3;
 
 /** Count regex hits without materializing the match array. */
-function countMatches(text: string, re: RegExp): number {
+export function countMatches(text: string, re: RegExp): number {
 	let count = 0;
 	re.lastIndex = 0;
 	while (re.exec(text) !== null) count++;
@@ -782,7 +782,7 @@ function countYellingSentences(text: string): number {
  * Each strip is replaced with a newline so subsequent line counting
  * reflects what was removed instead of merging neighbors.
  */
-function stripStructuredContent(text: string): string {
+export function stripStructuredContent(text: string): string {
 	return text
 		.replace(FENCED_CODE_RE, "\n")
 		.replace(XML_TAG_PAIR_RE, "\n")
@@ -800,11 +800,13 @@ function stripStructuredContent(text: string): string {
 export const PROSE_MAX_CHARS = 4000;
 
 /**
- * The prose a user message contributes to frustration judging: the same
+ * The prose a message contributes to behavioral analysis: the same
  * structured-content strip the regex signals score on, trimmed and capped at
  * {@link PROSE_MAX_CHARS}. Empty when the message was nothing but markup.
+ * Shared by the user-message judge and the model-side analyzer so both store
+ * exactly the same body.
  */
-export function judgeProse(text: string): string {
+export function analysisProse(text: string): string {
 	const prose = stripStructuredContent(text.trim()).trim();
 	return prose.length > PROSE_MAX_CHARS ? prose.slice(0, PROSE_MAX_CHARS) : prose;
 }