@oh-my-pi/pi-ai 17.3.4 → 17.3.7

package/src/usage/kimi.ts

@@ -2,6 +2,7 @@ import { toNumber } from "@oh-my-pi/pi-catalog/utils";
 import { $env } from "@oh-my-pi/pi-utils";
 import { getKimiCommonHeaders } from "../registry/oauth/kimi";
 import type {
+	CredentialRankingStrategy,
 	UsageAmount,
 	UsageFetchContext,
 	UsageFetchParams,
@@ -285,6 +286,7 @@ export const kimiUsageProvider: UsageProvider = {
 			fetchedAt: nowMs,
 			limits,
 			metadata: {
+				accountId: credential.accountId,
 				endpoint: url,
 			},
 			raw: parsed.raw,
@@ -293,3 +295,16 @@ export const kimiUsageProvider: UsageProvider = {
 		return report;
 	},
 };
+
+/** Ranks Kimi OAuth accounts by the canonical 5-hour and 7-day quota windows. */
+export const kimiRankingStrategy: CredentialRankingStrategy = {
+	findWindowLimits: report => ({
+		primary: report.limits.find(limit => limit.window?.id === "5h"),
+		secondary: report.limits.find(limit => limit.window?.id === "7d"),
+	}),
+	scopeLimits: report => report.limits.filter(limit => limit.window?.id === "5h" || limit.window?.id === "7d"),
+	windowDefaults: {
+		primaryMs: 5 * HOUR_MS,
+		secondaryMs: 7 * DAY_MS,
+	},
+};

package/src/usage/umans.ts

@@ -23,9 +23,14 @@ interface UmansUsagePayload {
 		requests?: { limit?: number; hard_cap?: number | null; window_seconds?: number };
 		concurrency?: { limit?: number; hard_cap?: number | null };
 	};
+	/** Rolling 5h window metadata; `resets_at` anchors the status-line countdown. */
+	window?: { started_at?: string; resets_at?: string; remaining_minutes?: number };
 	usage?: {
 		requests_in_window?: number;
 		remaining_requests?: number;
+		/** Model-weighted "effective requests" (umans-flash counts 0.5). */
+		weighted_in_window?: number;
+		weighted_remaining_requests?: number;
 		concurrent_sessions?: number;
 		tokens_in?: number;
 		tokens_out?: number;
@@ -55,6 +60,18 @@ function resolveStatus(usedFraction: number | undefined): UsageStatus | undefine
 	return "ok";
 }
 
+/**
+ * Soft-cap status never reaches `exhausted`: hitting the effective-request
+ * limit only means burst headroom is being consumed — Umans throttles (429)
+ * only near the burst ceiling, which the hard row tracks. `exhausted` must
+ * stay off this row or the usage-aware fallback demotes a healthy account.
+ */
+function softCapStatus(usedFraction: number | undefined): UsageStatus | undefined {
+	if (usedFraction === undefined) return undefined;
+	if (usedFraction >= 0.9) return "warning";
+	return "ok";
+}
+
 function buildAmount(args: {
 	used: number | undefined;
 	limit: number | undefined;
@@ -75,30 +92,88 @@ function buildAmount(args: {
 	};
 }
 
-function buildRequestsLimit(payload: UmansUsagePayload, provider: string): UsageLimit | null {
+function buildRequestsLimits(payload: UmansUsagePayload, provider: string): UsageLimit[] {
 	const limit = toFiniteNumber(payload.limits?.requests?.limit);
+	const hardCap = toFiniteNumber(payload.limits?.requests?.hard_cap);
 	const windowSeconds = toFiniteNumber(payload.limits?.requests?.window_seconds);
-	const used = toFiniteNumber(payload.usage?.requests_in_window);
-	const remaining = toFiniteNumber(payload.usage?.remaining_requests);
-	if (limit === undefined && used === undefined) return null;
-	const amount = buildAmount({ used, limit, remaining, unit: "requests" });
-	// Rolling window: each request ages out `window_seconds` after it fired, so
-	// there is no single reset timestamp. Surface the window size + label only.
-	// `window.id` is `"5h"` to match the status-line usage segment's window-id
-	// contract (it only recognizes `"5h"`/`"7d"`); `label` stays human-readable.
+	const rawUsed = toFiniteNumber(payload.usage?.requests_in_window);
+	const rawRemaining = toFiniteNumber(payload.usage?.remaining_requests);
+	const weightedUsed = toFiniteNumber(payload.usage?.weighted_in_window);
+	const weightedRemaining = toFiniteNumber(payload.usage?.weighted_remaining_requests);
+	if (limit === undefined && rawUsed === undefined && weightedUsed === undefined) return [];
+
+	// The 5h window is rolling (FIFO: each request ages out five hours after it
+	// fired), but the payload still reports an absolute `resets_at` for the
+	// current window epoch — surface it as an incremental countdown (`tick`)
+	// rather than a hard reset. `window.id` is `"5h"` to match the status-line
+	// usage segment's window-id contract (it only recognizes `"5h"`/`"7d"`).
+	let resetsAt: number | undefined;
+	if (payload.window?.resets_at) {
+		const parsed = Date.parse(payload.window.resets_at);
+		resetsAt = Number.isNaN(parsed) ? undefined : parsed;
+	}
 	const window: UsageWindow = {
 		id: "5h",
 		label: "rolling 5h",
 		durationMs: windowSeconds ? windowSeconds * 1000 : 5 * HOUR_MS,
+		...(resetsAt !== undefined ? { resetsAt, resetLabel: "tick" } : {}),
 	};
-	return {
-		id: "umans:requests",
-		label: "Requests (rolling 5h)",
-		scope: { provider, windowId: window.id, shared: true },
-		window,
-		amount,
-		status: resolveStatus(amount.usedFraction),
-	};
+
+	// Single row: either payloads without weighted counters (legacy) or payloads
+	// that report weighted usage but no burst ceiling (`hard_cap`). Without a
+	// burst ceiling there is no hard row to defer exhaustion to, so the
+	// authoritative counter — weighted when available, else raw — drives the
+	// single row and CAN exhaust at the limit. Raw burst traffic above the
+	// limit still never drives exhaustion on its own: weighted headroom stays
+	// decisive (https://github.com/can1357/oh-my-pi/issues/7858).
+	if (weightedUsed === undefined || hardCap === undefined) {
+		const amount = buildAmount({
+			used: weightedUsed ?? rawUsed,
+			limit,
+			remaining: weightedUsed !== undefined ? weightedRemaining : rawRemaining,
+			unit: "requests",
+		});
+		return [
+			{
+				id: "umans:requests",
+				label: "Requests (rolling 5h)",
+				scope: { provider, windowId: window.id, shared: true },
+				window,
+				amount,
+				status: resolveStatus(amount.usedFraction),
+			},
+		];
+	}
+
+	// Umans weights requests by model ("effective requests": umans-flash counts
+	// 0.5), so the weighted counters are the authoritative utilization against
+	// the soft `limit`; the raw counters include burst/superseded traffic and
+	// read as exhausted mid-window while the account still has weighted
+	// headroom (https://github.com/can1357/oh-my-pi/issues/7858). Soft cap hits
+	// warn; only the burst ceiling (`hard_cap`, raw counts) can exhaust.
+	const softAmount = buildAmount({ used: weightedUsed, limit, remaining: weightedRemaining, unit: "requests" });
+	const limits: UsageLimit[] = [
+		{
+			id: "umans:requests:soft",
+			label: "Requests (soft cap)",
+			scope: { provider, windowId: window.id, shared: true },
+			window,
+			amount: softAmount,
+			status: softCapStatus(softAmount.usedFraction),
+		},
+	];
+	if (hardCap !== undefined && rawUsed !== undefined) {
+		const hardAmount = buildAmount({ used: rawUsed, limit: hardCap, remaining: undefined, unit: "requests" });
+		limits.push({
+			id: "umans:requests:hard",
+			label: "Requests (burst ceiling)",
+			scope: { provider, windowId: window.id, shared: true },
+			window,
+			amount: hardAmount,
+			status: resolveStatus(hardAmount.usedFraction),
+		});
+	}
+	return limits;
 }
 
 function buildConcurrencyLimit(payload: UmansUsagePayload, provider: string): UsageLimit | null {
@@ -157,9 +232,7 @@ async function fetchUmansUsage(params: UsageFetchParams, ctx: UsageFetchContext)
 		return null;
 	}
 
-	const limits: UsageLimit[] = [];
-	const requests = buildRequestsLimit(payload, params.provider);
-	if (requests) limits.push(requests);
+	const limits: UsageLimit[] = [...buildRequestsLimits(payload, params.provider)];
 	const concurrency = buildConcurrencyLimit(payload, params.provider);
 	if (concurrency) limits.push(concurrency);
 	if (limits.length === 0) return null;

package/src/utils/leaked-thinking-stream.ts

@@ -25,7 +25,7 @@
  * events are forwarded verbatim.
  */
 
-import { isAnthropicWebSearchHistoryBlock } from "../providers/anthropic-wire";
+import { isAnthropicServerToolHistoryBlock } from "../providers/anthropic-wire";
 import type {
 	AnthropicServerToolContent,
 	AssistantMessage,
@@ -430,7 +430,7 @@ class LeakedThinkingProjector {
 		const pairedIndexes = new Set<number>();
 		for (let srcIndex = 0; srcIndex < message.content.length; srcIndex++) {
 			const content = message.content[srcIndex];
-			if (content?.type !== "anthropicServerTool" || !isAnthropicWebSearchHistoryBlock(content.block)) continue;
+			if (content?.type !== "anthropicServerTool" || !isAnthropicServerToolHistoryBlock(content.block)) continue;
 			if (content.block.type === "server_tool_use") {
 				pendingCalls.set(content.block.id, srcIndex);
 				continue;

package/src/utils/schema/strict-tool-validation.ts

@@ -7,8 +7,18 @@
  * copied onto a `type: "null"` branch, or an `enum` placed on an `array`
  * schema instead of its `items`). One such tool 400s the entire turn, so
  * callers quarantine just the offending tool. See issue #2652.
+ *
+ * xAI additionally rejects a leftover *root* `anyOf`/`oneOf` whose branches
+ * are not objects ("tool parameter root must be an object type"). That class
+ * is opt-in via {@link FindStrictToolSchemaViolationOptions.rejectXaiRootObjectUnion}
+ * so OpenAI/Azure/Codex keep valid object-root unions.
  */
 
+export interface FindStrictToolSchemaViolationOptions {
+	/** xAI (paid + OAuth) only: leftover object-root unions 400 the whole turn. */
+	rejectXaiRootObjectUnion?: boolean;
+}
+
 type JsonRecord = Record<string, unknown>;
 
 const SCHEMA_TYPE_NAMES: Record<string, true> = {
@@ -70,10 +80,14 @@ const CHILD_ARRAY_KEYS = ["anyOf", "oneOf", "allOf", "prefixItems"] as const;
  * contradictions. Returns a JSON-pointer-ish path to the first offending node,
  * or `null` when the schema is safe to emit.
  */
-export function findStrictToolSchemaViolation(schema: unknown, path = "#"): string | null {
+export function findStrictToolSchemaViolation(
+	schema: unknown,
+	path = "#",
+	options?: FindStrictToolSchemaViolationOptions,
+): string | null {
 	if (Array.isArray(schema)) {
 		for (let i = 0; i < schema.length; i++) {
-			const hit = findStrictToolSchemaViolation(schema[i], `${path}/${i}`);
+			const hit = findStrictToolSchemaViolation(schema[i], `${path}/${i}`, options);
 			if (hit) return hit;
 		}
 		return null;
@@ -91,25 +105,45 @@ export function findStrictToolSchemaViolation(schema: unknown, path = "#"): stri
 		}
 	}
 
+	// xAI rejects the whole request when the *root* schema is typed as object
+	// (or has properties) AND still carries an anyOf/oneOf with a typeless or
+	// non-object branch. Nested unions and pure root unions are not this error.
+	if (
+		options?.rejectXaiRootObjectUnion &&
+		path === "#" &&
+		(types.includes("object") || (node.properties !== undefined && typeof node.properties === "object"))
+	) {
+		for (const key of ["anyOf", "oneOf"] as const) {
+			const arr = node[key];
+			if (!Array.isArray(arr) || arr.length === 0) continue;
+			const hasNonObjectBranch = arr.some(branch => {
+				if (typeof branch !== "object" || branch === null || Array.isArray(branch)) return true;
+				const branchTypes = declaredTypes(branch as JsonRecord);
+				return !branchTypes.includes("object");
+			});
+			if (hasNonObjectBranch) return `${path}/${key}`;
+		}
+	}
+
 	for (const key of CHILD_MAP_KEYS) {
 		const sub = node[key];
 		if (sub && typeof sub === "object" && !Array.isArray(sub)) {
 			for (const k of Object.keys(sub as JsonRecord)) {
-				const hit = findStrictToolSchemaViolation((sub as JsonRecord)[k], `${path}/${key}/${k}`);
+				const hit = findStrictToolSchemaViolation((sub as JsonRecord)[k], `${path}/${key}/${k}`, options);
 				if (hit) return hit;
 			}
 		}
 	}
 	for (const key of CHILD_SCHEMA_KEYS) {
 		if (key in node) {
-			const hit = findStrictToolSchemaViolation(node[key], `${path}/${key}`);
+			const hit = findStrictToolSchemaViolation(node[key], `${path}/${key}`, options);
 			if (hit) return hit;
 		}
 	}
 	for (const key of CHILD_ARRAY_KEYS) {
 		const arr = node[key];
 		if (Array.isArray(arr)) {
-			const hit = findStrictToolSchemaViolation(arr, `${path}/${key}`);
+			const hit = findStrictToolSchemaViolation(arr, `${path}/${key}`, options);
 			if (hit) return hit;
 		}
 	}

package/src/utils/schema/wire.ts

@@ -204,6 +204,37 @@ function rewriteNullableScalarAnyOf(schema: Record<string, unknown>): void {
 	schema.type = [scalarType, "null"];
 }
 
+function isExclusiveRequiredBranch(branch: unknown): boolean {
+	if (!isSchemaRecord(branch)) return false;
+	if (Object.hasOwn(branch, "type")) return false;
+	if (!Array.isArray(branch.required) || branch.required.length === 0) return false;
+	if (!branch.required.every(name => typeof name === "string" && name.length > 0)) return false;
+	for (const key in branch) {
+		if (!Object.hasOwn(branch, key)) continue;
+		if (key === "required" || key === "description" || key === "title") continue;
+		return false;
+	}
+	return true;
+}
+
+/**
+ * Return an xAI-compatible copy of an object-root schema whose union consists
+ * only of typeless required-key fragments. Other providers must retain the
+ * union because it is a real model-facing constraint.
+ */
+export function flattenExclusiveRequiredRootUnion(schema: Record<string, unknown>): Record<string, unknown> {
+	const unionKey = Array.isArray(schema.anyOf) ? "anyOf" : Array.isArray(schema.oneOf) ? "oneOf" : undefined;
+	if (!unionKey) return schema;
+	const union = schema[unionKey];
+	if (!Array.isArray(union) || union.length === 0) return schema;
+	const typedObject = schema.type === "object" || (Array.isArray(schema.type) && schema.type.includes("object"));
+	if (!typedObject && !isSchemaRecord(schema.properties)) return schema;
+	if (!union.every(isExclusiveRequiredBranch)) return schema;
+	const flattened = { ...schema };
+	delete flattened[unionKey];
+	return flattened;
+}
+
 /** Keys whose values are a single JSON Schema (not an array or map). */
 const SCHEMA_VALUE_KEYS = [
 	"additionalProperties",

package/src/utils/thinking-loop.ts

@@ -8,15 +8,17 @@
  * or answering. The runaway is *not* byte-identical, so a cheap verbatim
  * tail-repeat check alone misses it.
  *
- * This guard watches the streamed `thinking` deltas and, on a match, terminates
- * the stream with a synthetic `error` {@link AssistantMessage} that carries
- * **no observable content**. An empty-content `stopReason: "error"` message tagged
- * with `AIError.Flag.ThinkingLoop` lets result consumers and `AgentSession` discard
- * the runaway and re-sample instead of committing garbage transcript.
+ * This guard watches streamed deltas and, on a match, terminates the stream with
+ * a synthetic `error` {@link AssistantMessage} whose terminal content is empty.
+ * Deltas emitted before enough evidence accumulates may already be observable to
+ * a live streaming consumer; the empty terminal prevents the failed attempt from
+ * being committed or replayed. Tagged with `AIError.Flag.ThinkingLoop`, the
+ * result lets `AgentSession` discard the runaway and re-sample.
  *
- * Three failure shapes are detected:
- * 1. **Verbatim tail repetition** — a short unit repeated back-to-back (e.g.
- *    "🌊 🌊 🌊 …"). Caught from a rolling 250-char tail.
+ * Four failure shapes are detected:
+ * 1. **Exact suffix cycles** — a byte-identical unit repeated back-to-back,
+ *    including long cycles such as the observed 311-character Kiro runaway.
+ *    This bounded detector applies to every model.
  * 2. **Near-duplicate segments** — paragraphs that normalize to the same
  *    word-trigram fingerprint. Caught with a Jaccard window over recent
  *    paragraphs. Thresholds were calibrated on a real loop transcript plus
@@ -28,13 +30,16 @@
  *    vocabulary and name nothing concrete. Caught by a run of low-novelty,
  *    anchor-free segments; a segment naming a path/identifier resets the run, so
  *    genuine but vocabulary-repetitive work (per-file templates) is spared.
+ * 4. **Gemini summary-header runaway** — handled separately by
+ *    {@link GeminiHeaderRunDetector}.
  *
- * Scope is narrow: guarded Gemini, DeepSeek, and Grok family streams before any tool call. Native
- * thinking is checked first; assistant text can also be checked for providers
- * that surface reasoning as visible prose. On a hit the failed turn is emitted as
- * an empty retryable stream-stall error; result-awaiting callers (`complete`,
- * `completeSimple`) re-sample it a few times and then let a stubborn loop cook
- * through one unguarded pass. Disable detection with `PI_NO_THINKING_LOOP_GUARD=1`.
+ * Scope: exact cycles are guarded for every model; semantic heuristics remain
+ * limited to Gemini, DeepSeek, and Grok family streams before any tool call.
+ * Native thinking is checked first; assistant text can also be checked for
+ * providers that surface reasoning as visible prose. On a hit the failed turn is
+ * emitted as an empty retryable stream-stall error; result-awaiting callers
+ * (`complete`, `completeSimple`) re-sample at most three guarded attempts and
+ * then fail closed. Disable detection with `PI_NO_THINKING_LOOP_GUARD=1`.
  */
 import { modelFamilyToken } from "@oh-my-pi/pi-catalog/identity";
 import { logger } from "@oh-my-pi/pi-utils";
@@ -47,12 +52,17 @@ import { AssistantMessageEventStream } from "./event-stream";
  *  classifiers treat it as a transient (retryable) stop without bespoke rules. */
 export const THINKING_LOOP_ERROR_MARKER = "Thinking loop detected";
 
-/** Rolling tail (chars) inspected for verbatim back-to-back repetition. */
-const VERBATIM_TAIL_WINDOW = 250;
-/** Minimum total repeated chars before a verbatim run counts as a loop. */
-const VERBATIM_MIN_REPEATED_CHARS = 180;
-/** Longest unit length probed for a verbatim repeat. */
-const VERBATIM_MAX_UNIT = 60;
+/** Rolling tail retained for exact suffix-cycle detection. */
+const EXACT_TAIL_WINDOW = 4096;
+/** Longest exact cycle length considered. */
+const EXACT_MAX_UNIT = 1024;
+/** New characters between scans. Large deltas are scanned immediately. */
+const EXACT_CHECK_STRIDE = 128;
+/** Short cycles need four repeats covering at least this many characters. */
+const EXACT_SHORT_MAX_UNIT = 60;
+const EXACT_SHORT_MIN_REPEATED_CHARS = 180;
+/** Long cycles need at least three repeats covering at least this many chars. */
+const EXACT_LONG_MIN_REPEATED_CHARS = 1024;
 
 /** Char cap for an unterminated segment; forces a flush so a wall-of-text loop
  *  (no blank lines / headings) still segments. */
@@ -96,11 +106,12 @@ const CONCRETE_ANCHOR =
 	/`[^`]+`|\b\w{2,}\.[a-zA-Z]\w{0,4}\b|[\w-]+(?:\/[\w-]+){2,}|\b\w+_\w+\b|\b[a-z]+[A-Z]\w*\b|\b[A-Z][a-z]+[A-Z]\w*\b/g;
 
 /**
- * True when `model.id` belongs to a family guarded for thinking/response loops:
- * Gemini, DeepSeek, or Grok.
+ * True when `model.id` belongs to a family guarded by the semantic loop
+ * heuristics: Gemini, DeepSeek, or Grok. Exact suffix-cycle detection applies to
+ * every enabled model independently of this predicate.
  *
  * Model identity is derived only from its id; provider and compatibility metadata
- * do not opt opaque aliases into the guard.
+ * do not opt opaque aliases into semantic detection.
  */
 export function isLoopGuardedModel(model: Model<Api>, options?: StreamOptions): boolean {
 	if (options?.loopGuard?.enabled === false) return false;
@@ -120,8 +131,10 @@ export function isLoopGuardedModel(model: Model<Api>, options?: StreamOptions):
  * is responsible for stopping after the first hit.
  */
 export class ThinkingLoopDetector {
-	/** Rolling char tail for verbatim repeat detection. */
+	/** Rolling char tail for exact suffix-cycle detection. */
 	#tail = "";
+	/** Total characters received when the exact detector last scanned. */
+	#exactScannedAt = 0;
 	/** Pending thinking text not yet split into completed segments. */
 	#pending = "";
 	/** Fingerprints of the most recent substantial segments (≤ SEGMENT_WINDOW). */
@@ -138,18 +151,27 @@ export class ThinkingLoopDetector {
 	 *  path/identifier every paragraph is still caught. */
 	#anchorWindow: Set<string>[] = [];
 
+	constructor(private readonly semanticHeuristics = true) {}
+
 	push(delta: string): string | null {
 		if (!delta) return null;
 
-		// 1. Verbatim back-to-back repetition over the rolling tail.
+		// 1. Exact suffix cycles. Scan at a bounded cadence rather than doing
+		// quadratic work for every token-sized delta.
 		this.#tail += delta;
-		if (this.#tail.length > VERBATIM_TAIL_WINDOW) this.#tail = this.#tail.slice(-VERBATIM_TAIL_WINDOW);
-		const verbatim = detectVerbatimRepetition(this.#tail);
-		if (verbatim) {
-			const [unit, times] = verbatim;
-			return `repeated "${unit.trim()}" ${times}× back-to-back`;
+		if (this.#tail.length > EXACT_TAIL_WINDOW) this.#tail = this.#tail.slice(-EXACT_TAIL_WINDOW);
+		this.#exactScannedAt += delta.length;
+		if (this.#exactScannedAt >= EXACT_CHECK_STRIDE || delta.length >= EXACT_CHECK_STRIDE) {
+			this.#exactScannedAt = 0;
+			const exact = detectExactSuffixCycle(this.#tail);
+			if (exact) {
+				const [unit, times] = exact;
+				return `repeated an exact ${unit.length}-character cycle ${times}× back-to-back`;
+			}
 		}
 
+		if (!this.semanticHeuristics) return null;
+
 		// 2. Near-duplicate paragraph loop. Append, then drain completed segments.
 		this.#pending += delta;
 		while (true) {
@@ -179,7 +201,14 @@ export class ThinkingLoopDetector {
 	 *  terminator). Called when the thinking block ends so the final segment —
 	 *  which may be the one that completes a duplicate cluster — is not dropped. */
 	flush(): string | null {
-		if (!this.#pending) return null;
+		// A stream can end before the next cadence boundary. Force one final exact
+		// check even when semantic heuristics are disabled and #pending is empty.
+		const exact = detectExactSuffixCycle(this.#tail);
+		if (exact) {
+			const [unit, times] = exact;
+			return `repeated an exact ${unit.length}-character cycle ${times}× back-to-back`;
+		}
+		if (!this.semanticHeuristics || !this.#pending) return null;
 		let rest = this.#pending;
 		this.#pending = "";
 		while (rest.length > 0) {
@@ -349,8 +378,9 @@ export function guardThinkingLoopStream(
 	options?: StreamOptions,
 ): AssistantMessageEventStream {
 	const outer = new AssistantMessageEventStream();
-	const thinkingDetector = new ThinkingLoopDetector();
-	const textDetector = new ThinkingLoopDetector();
+	const semanticHeuristics = isLoopGuardedModel(model, options);
+	const thinkingDetector = new ThinkingLoopDetector(semanticHeuristics);
+	const textDetector = new ThinkingLoopDetector(semanticHeuristics);
 	const checkAssistantContent = options?.loopGuard?.checkAssistantContent !== false;
 
 	void (async () => {
@@ -415,12 +445,12 @@ export function guardThinkingLoopStream(
 }
 
 /**
- * Apply the loop guard around a provider dispatch. For non-guarded models
- * (or when disabled) this is a transparent pass-through. For guarded models it injects a
- * guard abort signal into the provider call so a detected loop tears down the
- * upstream, then wraps the returned stream. The guard only raises the retryable
- * stall; bounding the re-samples and the final cook pass lives in the
- * result-awaiting caller.
+ * Apply the loop guard around a provider dispatch. Unless explicitly disabled,
+ * every model gets exact suffix-cycle detection; Gemini, DeepSeek, and Grok also
+ * get the semantic heuristics selected by {@link isLoopGuardedModel}. The guard
+ * injects an abort signal into the provider call so a detected loop tears down
+ * the upstream, then wraps the returned stream. Bounding result-path re-samples
+ * lives in the result-awaiting caller.
  */
 export function withThinkingLoopGuard<
 	O extends { signal?: AbortSignal; loopGuard?: { enabled?: boolean; checkAssistantContent?: boolean } },
@@ -429,7 +459,7 @@ export function withThinkingLoopGuard<
 	options: O | undefined,
 	dispatch: (options: O | undefined) => AssistantMessageEventStream,
 ): AssistantMessageEventStream {
-	if (process.env.PI_NO_THINKING_LOOP_GUARD === "1" || !isLoopGuardedModel(model, options)) {
+	if (process.env.PI_NO_THINKING_LOOP_GUARD === "1" || options?.loopGuard?.enabled === false) {
 		return dispatch(options);
 	}
 	const controller = new AbortController();
@@ -467,31 +497,34 @@ function buildThinkingLoopError(model: Model<Api>, detail: string): AssistantMes
 }
 
 /**
- * Detect a short unit repeated back-to-back at the tail (verbatim loop). Only a
- * unit carrying a letter or pictographic emoji counts — runs of digits,
- * whitespace or punctuation are legitimate in tabular / hex / numeric output.
+ * Detect an exact cycle at the text suffix. A Z-array over the reversed tail
+ * finds every possible suffix period in linear time without substring churn.
+ * Short cycles retain the original 180-character/four-repeat sensitivity; long
+ * cycles require at least three repeats and 1024 repeated characters.
  */
-function detectVerbatimRepetition(text: string): [unit: string, count: number] | null {
-	if (text.length < VERBATIM_MIN_REPEATED_CHARS) return null;
-	const windowSize = Math.min(text.length, VERBATIM_TAIL_WINDOW);
-	const searchSpace = text.slice(-windowSize);
-
-	for (let len = 2; len <= VERBATIM_MAX_UNIT; len++) {
-		if (searchSpace.length < len * 4) continue;
-		const unit = searchSpace.slice(-len);
-		if (!/[\p{L}\p{Extended_Pictographic}]/u.test(unit)) continue;
-
-		let count = 0;
-		let pos = searchSpace.length;
-		while (pos >= len) {
-			if (searchSpace.slice(pos - len, pos) === unit) {
-				count++;
-				pos -= len;
-			} else {
-				break;
-			}
+function detectExactSuffixCycle(text: string): [unit: string, count: number] | null {
+	if (text.length < EXACT_SHORT_MIN_REPEATED_CHARS) return null;
+	const reversed = text.split("").reverse().join("");
+	const z = new Uint16Array(reversed.length);
+	let left = 0;
+	let right = 0;
+	for (let i = 1; i < reversed.length; i++) {
+		if (i <= right) z[i] = Math.min(right - i + 1, z[i - left]);
+		while (i + z[i] < reversed.length && reversed[z[i]] === reversed[i + z[i]]) z[i]++;
+		if (i + z[i] - 1 > right) {
+			left = i;
+			right = i + z[i] - 1;
 		}
-		if (count >= 4 && len * count >= VERBATIM_MIN_REPEATED_CHARS) return [unit, count];
+	}
+
+	const maxUnit = Math.min(EXACT_MAX_UNIT, Math.floor(reversed.length / 3));
+	for (let len = 2; len <= maxUnit; len++) {
+		const count = 1 + Math.floor(z[len] / len);
+		const minCount = len <= EXACT_SHORT_MAX_UNIT ? 4 : 3;
+		const minChars = len <= EXACT_SHORT_MAX_UNIT ? EXACT_SHORT_MIN_REPEATED_CHARS : EXACT_LONG_MIN_REPEATED_CHARS;
+		if (count < minCount || len * count < minChars) continue;
+		const unit = text.slice(-len);
+		if (/\p{L}|\p{Extended_Pictographic}/u.test(unit)) return [unit, count];
 	}
 	return null;
 }