@iowarp/clio-coder 0.3.3 → 0.3.6

package/src/domains/middleware/memory-intervention.ts

@@ -1,4 +1,9 @@
 import { createHash } from "node:crypto";
+import {
+	legacyToolResultDigest,
+	sanitizeToolResultDigest,
+	type ToolResultDigest,
+} from "../../tools/result-disposition.js";
 import { TASK_MEMORY_DEFAULT_PROCEDURAL_CAP, type TaskMemoryBank } from "../memory/task-bank.js";
 import {
 	runTaskMemoryPolicy,
@@ -40,7 +45,6 @@ export interface MemoryInterventionSettings {
 	timeoutMs: number;
 }
 
-const RESULT_DIGEST_MAX_CHARS = 240;
 const CALL_DESCRIPTION_MAX_CHARS = 180;
 const NO_EFFECTS: ReadonlyArray<MiddlewareEffect> = [];
 
@@ -48,7 +52,7 @@ type ToolOutcome = "ok" | "error";
 
 interface PendingToolStep {
 	toolName: string;
-	fingerprint: string;
+	operationFingerprint: string;
 	callDescription: string;
 }
 
@@ -145,7 +149,7 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 	let toolStep = 0;
 	let lastTurnEndStep = 0;
 	let reactivateAfterCompaction = false;
-	let lastInjectedFingerprint: string | null = null;
+	let lastInjectedOperationFingerprint: string | null = null;
 	let currentTask = "(current task unavailable)";
 	let toolsSinceMemoryStep = 0;
 	let consecutiveErrors = 0;
@@ -202,6 +206,9 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 						return effects;
 					}
 					case "on_compaction":
+						// Recall grows the working set; it is an observability point, not
+						// context loss that should reactivate compacted task memory.
+						if (input.metadata?.stage === "working_set_recall") return NO_EFFECTS;
 						reactivateAfterCompaction = true;
 						return NO_EFFECTS;
 					case "turn_start": {
@@ -464,13 +471,13 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 	function observeBeforeTool(input: MiddlewareHookInput): void {
 		const prepared = prepareToolStep(input);
 		if (prepared === null) return;
-		setBounded(pending, pendingKey(input, prepared.fingerprint), prepared, settings().windowSteps);
+		setBounded(pending, pendingKey(input, prepared.operationFingerprint), prepared, settings().windowSteps);
 	}
 
 	function observeAfterTool(input: MiddlewareHookInput): ReadonlyArray<MiddlewareEffect> {
 		const fallback = prepareToolStep(input);
 		if (fallback === null) return NO_EFFECTS;
-		const key = pendingKey(input, fallback.fingerprint);
+		const key = pendingKey(input, fallback.operationFingerprint);
 		const prepared = pending.get(key) ?? fallback;
 		pending.delete(key);
 		const outcome = input.metadata?.resultKind === "error" ? "error" : "ok";
@@ -484,11 +491,13 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 		} else {
 			consecutiveErrors = 0;
 		}
+		const digest = resultDigest(input, outcome);
 		const step: TrajectoryStep = {
 			...prepared,
 			step: toolStep,
 			outcome,
-			resultDigest: resultDigest(input, outcome),
+			resultDigest: digest.text,
+			resultDigestProvenance: digest.provenance,
 		};
 		trajectory.push(step);
 		if (trajectory.length > live.windowSteps) trajectory.splice(0, trajectory.length - live.windowSteps);
@@ -504,20 +513,20 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 	 * itself, which the model reads on its very next round.
 	 */
 	function annotateRepeatedFailure(step: TrajectoryStep): ReadonlyArray<MiddlewareEffect> {
-		if (annotatedThisTurn.has(step.fingerprint)) return NO_EFFECTS;
+		if (annotatedThisTurn.has(step.operationFingerprint)) return NO_EFFECTS;
 		const occurrences = trajectory.filter(
-			(candidate) => candidate.outcome === "error" && candidate.fingerprint === step.fingerprint,
+			(candidate) => candidate.outcome === "error" && candidate.operationFingerprint === step.operationFingerprint,
 		).length;
-		const failure = failures.get(step.fingerprint);
+		const failure = failures.get(step.operationFingerprint);
 		if (occurrences < 2 || failure === undefined) return NO_EFFECTS;
 		const message = boundedReminder(
 			`Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}. Change the approach rather than repeating it.`,
 			settings().maxTokens,
 		);
 		if (message.length === 0) return NO_EFFECTS;
-		annotatedThisTurn.add(step.fingerprint);
+		annotatedThisTurn.add(step.operationFingerprint);
 		// Claim the turn-end channel too, so one repeated failure is surfaced once.
-		lastInjectedFingerprint = step.fingerprint;
+		lastInjectedOperationFingerprint = step.operationFingerprint;
 		lastDecision = "injected";
 		rulesInjectedSincePromptedStep = true;
 		annotatedSinceTurnEnd = true;
@@ -527,7 +536,7 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 	}
 
 	function rememberFailure(step: TrajectoryStep): void {
-		const previous = failures.get(step.fingerprint);
+		const previous = failures.get(step.operationFingerprint);
 		const attempts = (previous?.attempts ?? 0) + 1;
 		const firstStep = previous?.firstStep ?? step.step;
 		const content = proceduralContent(step.callDescription, attempts, firstStep, step.resultDigest);
@@ -543,7 +552,7 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 		}
 		setBounded(
 			failures,
-			step.fingerprint,
+			step.operationFingerprint,
 			{
 				entryId,
 				attempts,
@@ -563,21 +572,21 @@ export function createMemoryInterventionRegistration(deps: MemoryInterventionDep
 					step === undefined ||
 					step.outcome !== "error" ||
 					step.step <= lastTurnEndStep ||
-					step.fingerprint === lastInjectedFingerprint
+					step.operationFingerprint === lastInjectedOperationFingerprint
 				) {
 					continue;
 				}
 				const occurrences = trajectory.filter(
-					(candidate) => candidate.outcome === "error" && candidate.fingerprint === step.fingerprint,
+					(candidate) => candidate.outcome === "error" && candidate.operationFingerprint === step.operationFingerprint,
 				).length;
-				const failure = failures.get(step.fingerprint);
+				const failure = failures.get(step.operationFingerprint);
 				if (occurrences < 2 || failure === undefined) continue;
 				const message = boundedReminder(
 					`Memory: [${failure.entryId}] you already tried ${failure.callDescription} at step ${failure.firstStep} and it failed with ${failure.errorDigest}.`,
 					settings().maxTokens,
 				);
 				if (message.length === 0) return NO_EFFECTS;
-				lastInjectedFingerprint = step.fingerprint;
+				lastInjectedOperationFingerprint = step.operationFingerprint;
 				lastInjectedMessage = message;
 				lastDecision = "injected";
 				rulesInjectedSincePromptedStep = true;
@@ -621,31 +630,35 @@ function prepareToolStep(input: MiddlewareHookInput): PendingToolStep | null {
 	const canonical = hashToolCall(toolName, input.toolArgs ?? {});
 	return {
 		toolName,
-		fingerprint: createHash("sha256").update(canonical).digest("hex").slice(0, 16),
+		operationFingerprint: createHash("sha256").update(canonical).digest("hex").slice(0, 16),
 		callDescription: shortText(canonical, CALL_DESCRIPTION_MAX_CHARS),
 	};
 }
 
-function pendingKey(input: MiddlewareHookInput, fingerprint: string): string {
-	return input.toolCallId ?? `anonymous:${fingerprint}`;
+function pendingKey(input: MiddlewareHookInput, operationFingerprint: string): string {
+	return input.toolCallId ?? `anonymous:${operationFingerprint}`;
 }
 
-function resultDigest(input: MiddlewareHookInput, outcome: ToolOutcome): string {
+function resultDigest(input: MiddlewareHookInput, outcome: ToolOutcome): ToolResultDigest {
+	if (input.toolResultDigest !== undefined) return sanitizeToolResultDigest(input.toolResultDigest);
 	if (outcome === "error") {
 		const metadataMessage = input.metadata?.errorMessage;
 		if (typeof metadataMessage === "string" && metadataMessage.trim().length > 0) {
-			return shortText(diagnosticLine(metadataMessage), RESULT_DIGEST_MAX_CHARS);
+			return legacyToolResultDigest(diagnosticLine(metadataMessage), { outcome });
 		}
 		for (const key of ["error", "message"] as const) {
 			const value = input.toolResultDetails?.[key];
 			if (typeof value === "string" && value.trim().length > 0) {
-				return shortText(diagnosticLine(value), RESULT_DIGEST_MAX_CHARS);
+				return legacyToolResultDigest(diagnosticLine(value), { outcome });
 			}
 		}
-		return "an unknown tool error";
+		return legacyToolResultDigest("", { outcome });
 	}
 	const resultFingerprint = input.metadata?.resultFingerprint;
-	return typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok";
+	return legacyToolResultDigest(
+		typeof resultFingerprint === "string" ? `ok result ${resultFingerprint.slice(0, 16)}` : "ok",
+		{ outcome },
+	);
 }
 
 const DIAGNOSTIC_HINT =

package/src/domains/middleware/runtime.ts

@@ -328,6 +328,12 @@ function cloneHookInput(input: MiddlewareHookInput): MiddlewareHookInput {
 	if (input.metadata !== undefined) cloned.metadata = { ...input.metadata };
 	if (input.toolArgs !== undefined) cloned.toolArgs = { ...input.toolArgs };
 	if (input.toolResultDetails !== undefined) cloned.toolResultDetails = { ...input.toolResultDetails };
+	if (input.toolResultDigest !== undefined) {
+		cloned.toolResultDigest = {
+			text: input.toolResultDigest.text,
+			provenance: { ...input.toolResultDigest.provenance },
+		};
+	}
 	if (input.text !== undefined) cloned.text = input.text.slice(0, MIDDLEWARE_HOOK_TEXT_MAX_CHARS);
 	return cloned;
 }

package/src/domains/middleware/skills-reminder.ts

@@ -1,5 +1,6 @@
 import { SKILL_SUGGESTION_ANCHOR } from "../../core/skill-activation.js";
 import type { MiddlewareHookRegistration } from "./runtime.js";
+import { isSkillSuggestionWait, SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE } from "./stalled-turn.js";
 import { type MiddlewareEffect, metadataNumber } from "./types.js";
 
 /**
@@ -32,12 +33,17 @@ export function skillsReminderMessage(installed: number, installable = 0): strin
 		installable > 0
 			? `${installed} installed, ${installable} installable from the marketplace`
 			: `${installed} installed`;
+	// Inline and non-blocking (issue #184): a 27B model read "and wait for the
+	// operator" as the whole job, spent a 40-second turn deliberating over the
+	// suggestion, and ended without one repository read. The suggestion is one
+	// line, the task continues in the same turn, and only the operator loads.
 	return (
 		`[Skills] ${counts}. Start this task by listing them with context(scope="skills") ` +
 		"and checking for a match; if one matches, open your reply with the line " +
 		`\`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) ` +
-		"and wait for the operator; load only on operator request, and a marketplace skill is offered for " +
-		"install when the operator runs it. If none match, do not mention skills and continue with the task."
+		"and then continue the task in the same turn without the skill. Only the operator loads a skill, and a " +
+		"marketplace skill is offered for install when the operator runs it. If none match, do not mention skills " +
+		"and continue with the task."
 	);
 }
 
@@ -135,9 +141,18 @@ export function createSkillsReminderRegistration(deps: SkillsReminderDeps): Midd
 
 	return {
 		id: SKILLS_REMINDER_REGISTRATION_ID,
-		description: "once per session, on the first substantive turn, teaches the skill-suggestion reply protocol",
-		hooks: ["turn_start"],
+		description:
+			"once per session, on the first substantive turn, teaches the skill-suggestion reply protocol; keeps a turn going that stopped on the suggestion",
+		hooks: ["turn_start", "turn_end"],
 		evaluate(input): ReadonlyArray<MiddlewareEffect> {
+			// The registration that teaches "suggest, then continue" owns the
+			// consequence when a model suggests and stops. The generic stalled-turn
+			// rule cannot see this case: the listing call counts as a tool call.
+			if (input.hook === "turn_end") {
+				return isSkillSuggestionWait(input)
+					? [{ kind: "request_continuation", message: SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE }]
+					: NO_EFFECTS;
+			}
 			const sessionId = input.sessionId ?? null;
 			if (lastSeenSessionId === undefined) {
 				lastSeenSessionId = sessionId;

package/src/domains/middleware/stalled-turn.ts

@@ -1,13 +1,127 @@
+import { SKILL_SUGGESTION_PREFIX } from "../../core/skill-activation.js";
+import { ToolNames } from "../../core/tool-names.js";
 import type { MiddlewareRuleDefinition } from "./runtime.js";
-import type { MiddlewareHookInput } from "./types.js";
+import { type MiddlewareHookInput, metadataNumber, metadataString } from "./types.js";
 
 export const STALLED_TURN_REGISTRATION_ID = "nudge.stalled-turn";
 
 export const STALLED_TURN_REQUEST_CONTINUATION_MESSAGE =
 	"You ended your turn after announcing an action without executing it: no tools were called. Continue now and perform the announced action, or state plainly that you are finished and waiting for the user.";
 
+export const SKILL_SUGGESTION_WAIT_CONTINUATION_MESSAGE =
+	"You ended your turn on a skill suggestion without doing the task. The suggestion line has already made the offer and only the operator loads a skill, so nothing is needed from them before you proceed. Continue the task now without the skill.";
+
 const INTENT_PATTERN = /\b(let me|i['’]ll|i will|i am going to|i['’]m going to|now i|next i|let's|let us)\b/i;
+
+// Bare stems only. Inflected forms are derived below so that "running",
+// "checking", and "verifies" count as the same announced action as "run".
+const CONCRETE_ACTION_STEMS = [
+	"add",
+	"analyse",
+	"analyze",
+	"apply",
+	"audit",
+	"build",
+	"change",
+	"check",
+	"compare",
+	"compile",
+	"create",
+	"debug",
+	"delete",
+	"edit",
+	"execute",
+	"explore",
+	"find",
+	"fix",
+	"format",
+	"grep",
+	"implement",
+	"inspect",
+	"install",
+	"investigate",
+	"list",
+	"load",
+	"look",
+	"modify",
+	"open",
+	"patch",
+	"query",
+	"read",
+	"refactor",
+	"remove",
+	"rename",
+	"replace",
+	"review",
+	"run",
+	"scan",
+	"search",
+	"test",
+	"trace",
+	"update",
+	"validate",
+	"verify",
+	"write",
+] as const;
+
+// Stems whose final consonant doubles before a vowel suffix.
+const DOUBLED_CONSONANT_STEMS = new Set(["debug", "format", "run", "scan"]);
+
+function concreteActionForms(stem: string): string[] {
+	const forms = new Set([stem, `${stem}s`, `${stem}ed`, `${stem}ing`]);
+	if (/(?:ch|sh|s|x|z)$/.test(stem)) forms.add(`${stem}es`);
+	if (stem.endsWith("e")) {
+		forms.add(`${stem}d`);
+		forms.add(`${stem.slice(0, -1)}ing`);
+	}
+	if (stem.endsWith("y")) {
+		forms.add(`${stem.slice(0, -1)}ies`);
+		forms.add(`${stem.slice(0, -1)}ied`);
+	}
+	if (DOUBLED_CONSONANT_STEMS.has(stem)) {
+		const doubled = `${stem}${stem.slice(-1)}`;
+		forms.add(`${doubled}ed`);
+		forms.add(`${doubled}ing`);
+	}
+	return [...forms];
+}
+
+const CONCRETE_ACTION_PATTERN = new RegExp(
+	`\\b(?:${CONCRETE_ACTION_STEMS.flatMap(concreteActionForms).join("|")})\\b`,
+	"giu",
+);
+
+// Extensions a model actually names when announcing work on a file. Requiring
+// one (or an explicit ./, ../, ~/ prefix) keeps "and/or" and "I/O" from
+// reading as paths.
+const NAMED_PATH_EXTENSIONS =
+	"c|cc|cfg|cjs|cmake|conf|cpp|cs|css|csv|env|go|h|hpp|html|ini|java|jl|js|json|jsx|lock|log|lua|md|mjs|nc|php|py|rb|rs|rst|sh|sql|toml|ts|tsx|txt|yaml|yml";
+const NAMED_PATH_PATTERN = new RegExp(
+	`(?:^|[\\s\`"'(\\[])(?:[\\w@.\\-/]*[\\w@\\-]\\.(?:${NAMED_PATH_EXTENSIONS})\\b|(?:\\.{1,2}|~)\\/[\\w@.\\-/]+)`,
+	"iu",
+);
+
+// A named executable followed by at least one argument token. Words that are
+// ordinary English on their own ("go", "make", "test") are deliberately absent.
+const NAMED_COMMAND_PATTERN =
+	/\b(?:npm|npx|pnpm|yarn|bun|git|cargo|rustc|cmake|ctest|ninja|meson|bazel|gradle|mvn|pytest|pip|python3?|node|deno|tsc|biome|eslint|prettier|jest|vitest|ruff|mypy|docker|kubectl|mpirun|srun|sbatch|gcc|clang)\s+[-\w./]/iu;
+
+const ACTION_OBJECT_CONNECTOR_PATTERN = /^(?:at|for|in|into|on|through|to)\s+/i;
+const ACTION_OBJECT_DETERMINER_PATTERN = /^(?:a|an|my|our|that|the|their|these|this|those|your)\s+/i;
+const ACTION_OBJECT_PATTERN = /^(?!(?:again|everyone|later|next|now|soon|then|you)\b)[`"'./~]*[\p{L}\p{N}_-]/iu;
+const CONDITIONAL_LEAD_IN_PATTERN = /\b(?:if|once|unless|until|when|whenever)\b/i;
+const CONDITIONAL_INVITATION_PATTERN = /\b(?:ask|give|point|say|send|share|tell)\b[\s\S]*\b(?:and|then)\s*$/i;
+// "if needed", and any conditional whose condition is about the user: "if you
+// want", "if that is what you need". Conditions about the work ("if the config
+// is valid") stay announcements.
+const CONDITIONAL_OFFER_SUFFIX_PATTERN =
+	/\b(?:if\s+(?:needed|necessary|requested)\b|if\b[^.!?]*\byou\b|when(?:ever)?\s+you\b)/i;
 const LET_ME_KNOW_PATTERN = /\blet me know\b/i;
+// "I'll wait for your go-ahead before I touch src/cli/index.ts" names a path
+// and promises nothing now. A clause that opens by deferring is a wait
+// statement whatever it goes on to name, so it is read before any verb or
+// path inside it can count as an announcement.
+const DEFERRAL_LEAD_PATTERN = /^\s*(?:just\s+|simply\s+|now\s+)?(?:wait|hold\s+off|hold|stand\s+by|pause|defer)\b/i;
 const COMPLETION_PATTERN =
 	/^\s*(?:all\s+done|done|complete|completed|all\s+set)\b|^\s*(?:here(?:'s| is)\s+)?(?:a\s+)?summary\b|^\s*summary\s*:?$/i;
 
@@ -24,6 +138,43 @@ export const STALLED_TURN_RULE_DEFINITION: MiddlewareRuleDefinition = {
 	predicate: shouldRequestStalledTurnContinuation,
 };
 
+// "run /skill X or say skip", "Suggested skill: /skill x", "want me to use
+// the skill?": the sentence hands the operator a decision the protocol does
+// not require of them.
+const SKILL_WAIT_PATTERN = /\/skill\b|\bskills?\b|\bskip\b/i;
+
+/**
+ * A turn that made the skill suggestion and then stopped, with only the
+ * listing call behind it (issue #184). The generic stalled-turn predicate
+ * cannot see this: `context(scope="skills")` is a tool call, so the turn
+ * looks busy, and "say skip and I'll explore the tree" reads as a
+ * conditional offer rather than an announcement. The suggestion is supposed
+ * to be one inline line before the work, so a reply that is the suggestion
+ * plus a wait has not done the task.
+ */
+export function isSkillSuggestionWait(input: MiddlewareHookInput): boolean {
+	if (input.hook !== "turn_end") return false;
+	if (!isNormalStopReason(input.metadata?.stopReason)) return false;
+	const text = input.text ?? "";
+	if (!text.includes(SKILL_SUGGESTION_PREFIX)) return false;
+	const toolNames = metadataString(input, "turnToolNames");
+	if (toolNames === null) {
+		if ((metadataNumber(input, "turnToolCalls") ?? 0) !== 0) return false;
+	} else if (
+		toolNames
+			.split(",")
+			.filter((name) => name.length > 0)
+			.some((name) => name !== ToolNames.Context)
+	) {
+		return false;
+	}
+	const lastLine = lastNonEmptyLine(text);
+	if (lastLine === null) return false;
+	const finalSentence = lastSentence(lastLine);
+	if (finalSentence.length === 0) return false;
+	return SKILL_WAIT_PATTERN.test(finalSentence) || isQuestion(finalSentence) || LET_ME_KNOW_PATTERN.test(finalSentence);
+}
+
 export function shouldRequestStalledTurnContinuation(input: MiddlewareHookInput): boolean {
 	if (input.hook !== "turn_end") return false;
 	if (input.metadata?.turnToolCalls !== 0) return false;
@@ -38,7 +189,47 @@ export function shouldRequestStalledTurnContinuation(input: MiddlewareHookInput)
 	if (LET_ME_KNOW_PATTERN.test(finalSentence)) return false;
 	if (COMPLETION_PATTERN.test(lastLine) || COMPLETION_PATTERN.test(finalSentence)) return false;
 
-	return finalSentence.endsWith(":") || INTENT_PATTERN.test(finalSentence);
+	return announcesConcreteAction(finalSentence);
+}
+
+function announcesConcreteAction(sentence: string): boolean {
+	const intent = INTENT_PATTERN.exec(sentence);
+	if (intent) {
+		const leadIn = sentence.slice(0, intent.index);
+		if (
+			CONDITIONAL_LEAD_IN_PATTERN.test(leadIn) ||
+			CONDITIONAL_INVITATION_PATTERN.test(leadIn) ||
+			CONDITIONAL_OFFER_SUFFIX_PATTERN.test(sentence)
+		) {
+			return false;
+		}
+		const clause = sentence.slice(intent.index + intent[0].length);
+		if (DEFERRAL_LEAD_PATTERN.test(clause)) return false;
+		if (hasActionWithObject(clause)) return true;
+		// A path or command is evidence of an immediate action only when the
+		// announcement itself is unconditional; "once package.json is updated"
+		// names a file but promises nothing now.
+		if (CONDITIONAL_LEAD_IN_PATTERN.test(clause)) return false;
+		return namesToolTarget(clause);
+	}
+
+	// A trailing colon can still signal a cut-off action lead-in, but only when
+	// the lead-in names work and its target instead of relying on punctuation.
+	return sentence.endsWith(":") && hasActionWithObject(sentence);
+}
+
+function namesToolTarget(clause: string): boolean {
+	return NAMED_PATH_PATTERN.test(clause) || NAMED_COMMAND_PATTERN.test(clause);
+}
+
+function hasActionWithObject(clause: string): boolean {
+	for (const action of clause.matchAll(CONCRETE_ACTION_PATTERN)) {
+		const remainder = clause.slice((action.index ?? 0) + action[0].length).trimStart();
+		const withoutConnector = remainder.replace(ACTION_OBJECT_CONNECTOR_PATTERN, "");
+		const object = withoutConnector.replace(ACTION_OBJECT_DETERMINER_PATTERN, "");
+		if (ACTION_OBJECT_PATTERN.test(object)) return true;
+	}
+	return false;
 }
 
 function isNormalStopReason(value: unknown): boolean {
@@ -60,10 +251,22 @@ function lastNonEmptyLine(text: string): string | null {
 	return null;
 }
 
+// A period only terminates a sentence when it ends a token: "bash.ts" and
+// "package.json" must survive extraction intact.
+const SENTENCE_TERMINATOR_PATTERN = /[.!?]+["'’)\]]*(?=\s|$)/gu;
+
 function lastSentence(line: string): string {
-	const matches = line.match(/[^.!?]+[.!?]+(?:["')\]]+)?|[^.!?]+$/g);
-	const sentence = matches?.at(-1)?.trim() ?? line.trim();
-	return sentence.replace(/^[\s"'([{-]+/, "").trim();
+	const trimmed = line.trimEnd();
+	let start = 0;
+	for (const terminator of trimmed.matchAll(SENTENCE_TERMINATOR_PATTERN)) {
+		const end = (terminator.index ?? 0) + terminator[0].length;
+		if (end >= trimmed.length) break;
+		start = end;
+	}
+	return trimmed
+		.slice(start)
+		.replace(/^[\s"'([{-]+/, "")
+		.trim();
 }
 
 function isQuestion(sentence: string): boolean {

package/src/domains/middleware/types.ts

@@ -1,3 +1,5 @@
+import type { ToolResultDigest } from "../../tools/result-disposition.js";
+
 /**
  * The five lifecycle events of the unified middleware layer (w3 cutover).
  * Every event has a live producer: the registry fires before_tool/after_tool
@@ -86,6 +88,8 @@ export interface MiddlewareHookInput {
 	toolArgs?: Readonly<Record<string, unknown>>;
 	/** Structured result details, supplied by the registry on after_tool. Read-only by contract. */
 	toolResultDetails?: Readonly<Record<string, unknown>>;
+	/** Bounded deterministic diagnostic supplied by the result-disposition layer on after_tool. */
+	toolResultDigest?: Readonly<ToolResultDigest>;
 	/**
 	 * Free text attached to the hook occurrence; on turn_end this is the final
 	 * assistant message text. The one typed exception to the scalar `metadata`
@@ -114,6 +118,12 @@ export function metadataNumber(input: MiddlewareHookInput, key: string): number
 	return typeof value === "number" && Number.isFinite(value) ? value : null;
 }
 
+/** The string under `key`, or null when the caller did not report one. */
+export function metadataString(input: MiddlewareHookInput, key: string): string | null {
+	const value = input.metadata?.[key];
+	return typeof value === "string" ? value : null;
+}
+
 export function isMiddlewareHook(value: string): value is MiddlewareHook {
 	return (MIDDLEWARE_HOOKS as ReadonlyArray<string>).includes(value);
 }

package/src/domains/observability/contract.ts

@@ -1,3 +1,4 @@
+import type { ResponseModelIdObservationCounts } from "../../core/response-model-id.js";
 import type { TargetStatus } from "../providers/contract.js";
 import type { CostProvenance } from "../providers/index.js";
 import type { AccountabilitySummary } from "./accountability.js";
@@ -132,11 +133,15 @@ export interface ObservabilityContract {
 	 */
 	recordTokens(
 		providerId: string,
-		modelId: string,
+		attributedModelId: string,
 		tokens: number,
 		costUsd?: number,
 		breakdown?: Partial<UsageBreakdown>,
 		costProvenance?: CostProvenance,
+		modelIdFacts?: {
+			requestedModelIds: ReadonlyArray<string>;
+			responseModelIdObservationCounts: Readonly<ResponseModelIdObservationCounts>;
+		},
 	): void;
 	/** Record final output token throughput for one completed assistant stream. */
 	recordTokenThroughput(snapshot: TokenThroughputSnapshot): void;

package/src/domains/observability/cost.ts

@@ -11,6 +11,7 @@
  * footer consumes the session sum through `ObservabilityContract.sessionTokens()`.
  */
 
+import type { ResponseModelIdObservationCounts } from "../../core/response-model-id.js";
 import { type CostProvenance, normalizeCostProvenance } from "../providers/index.js";
 
 export interface CostAmount {
@@ -112,7 +113,9 @@ export interface UsageBreakdown {
 
 export interface CostEntry {
 	providerId: string;
-	modelId: string;
+	attributedModelId: string;
+	requestedModelIds: string[];
+	responseModelIdObservationCounts: ResponseModelIdObservationCounts;
 	tokens: number;
 	usd: number;
 	provenance: CostProvenance;
@@ -127,11 +130,15 @@ export interface CostEntry {
 export interface CostTracker {
 	accumulate(
 		providerId: string,
-		modelId: string,
+		attributedModelId: string,
 		tokens: number,
 		usd?: number,
 		breakdown?: Partial<UsageBreakdown>,
 		provenance?: CostProvenance,
+		modelIdFacts?: {
+			requestedModelIds: ReadonlyArray<string>;
+			responseModelIdObservationCounts: Readonly<ResponseModelIdObservationCounts>;
+		},
 	): number;
 	sessionTotal(): number;
 	sessionCost(): CostAggregate;
@@ -149,7 +156,7 @@ export function createCostTracker(): CostTracker {
 	let total = 0;
 	const totals = emptyBreakdown();
 	return {
-		accumulate(providerId, modelId, tokens, usd, breakdown, costProvenance) {
+		accumulate(providerId, attributedModelId, tokens, usd, breakdown, costProvenance, modelIdFacts) {
 			const resolvedUsd = usd ?? 0;
 			const provenance = normalizeCostProvenance(costProvenance);
 			const input = breakdown?.input ?? 0;
@@ -160,7 +167,16 @@ export function createCostTracker(): CostTracker {
 			const apiCalls = breakdown?.apiCalls;
 			log.push({
 				providerId,
-				modelId,
+				attributedModelId,
+				requestedModelIds: [...(modelIdFacts?.requestedModelIds ?? [attributedModelId])],
+				responseModelIdObservationCounts: modelIdFacts
+					? { ...modelIdFacts.responseModelIdObservationCounts }
+					: {
+							reportedCalls: 0,
+							notReportedCalls: 0,
+							notObservedCalls: apiCalls ?? 1,
+							legacyDifferenceOnlyCalls: 0,
+						},
 				tokens,
 				usd: resolvedUsd,
 				provenance,

package/src/domains/observability/extension.ts

@@ -259,9 +259,9 @@ export function createObservabilityBundle(
 			latestThroughput = null;
 			projection.refresh();
 		},
-		recordTokens(providerId, modelId, tokens, costUsd, breakdown, costProvenance) {
+		recordTokens(providerId, attributedModelId, tokens, costUsd, breakdown, costProvenance, modelIdFacts) {
 			telemetry.record("counter", "tokens.total", tokens);
-			cost.accumulate(providerId, modelId, tokens, costUsd, breakdown, costProvenance);
+			cost.accumulate(providerId, attributedModelId, tokens, costUsd, breakdown, costProvenance, modelIdFacts);
 			projection.refresh();
 		},
 		recordSessionTurn(sessionTurn) {

package/src/domains/providers/index.ts

@@ -32,6 +32,7 @@ export type { ModelCapabilityPatchTarget } from "./model-capabilities.js";
 export { applyModelCapabilityPatch, resolveModelCapabilities } from "./model-capabilities.js";
 export {
 	canonicalizeWireModelId,
+	contextSlotsForModel,
 	hasLiveModelCatalog,
 	loadedContextWindowForModel,
 	type ModelResidency,
@@ -96,6 +97,7 @@ export {
 	refineRuntimeTargetWithModelHints,
 	resolveRuntimeTarget,
 	runtimeResolutionWarnings,
+	runtimeResolutionWarningsBesideThinkingNotice,
 	runtimeTargetSnapshot,
 } from "./runtime-resolution.js";
 export {
@@ -126,6 +128,7 @@ export {
 	EMPTY_CAPABILITIES,
 	VALID_THINKING_LEVELS,
 } from "./types/capability-flags.js";
+export { type ContextWindowSlots, formatContextWindowSlots } from "./types/context-window-slots.js";
 export { type CostProvenance, normalizeCostProvenance } from "./types/cost-provenance.js";
 export type { KnowledgeBase, KnowledgeBaseEntry, KnowledgeBaseHit } from "./types/knowledge-base.js";
 export type {

package/src/domains/providers/model-discovery.ts

@@ -1,5 +1,6 @@
 import type { TargetStatus } from "./contract.js";
 import { listKnownModelsForRuntime } from "./support.js";
+import type { ContextWindowSlots } from "./types/context-window-slots.js";
 
 export type ProviderModelSource = "configured" | "live" | "catalog" | "default";
 
@@ -45,6 +46,14 @@ export function loadedContextWindowForModel(
 	return typeof reported === "number" && Number.isFinite(reported) && reported > 0 ? reported : null;
 }
 
+/** How the server splits its KV budget for this model, when the probe saw it split. */
+export function contextSlotsForModel(
+	status: DiscoveryStatus | null | undefined,
+	modelId: string,
+): ContextWindowSlots | null {
+	return status?.discoveredModelStates?.[modelId]?.contextSlots ?? null;
+}
+
 /**
  * Residency as one view, so the planner and the "not resident" notice cannot
  * disagree about the same model. A reported loaded window settles it whatever