jeopi-cli 16.2.25 → 16.2.27

package/src/memories/index.ts

@@ -698,12 +698,34 @@ function extractPersistableMessages(payload: string): AgentMessage[] {
 		if (!maybeMessage || typeof maybeMessage !== "object") continue;
 		const message = maybeMessage as AgentMessage;
 		if (shouldPersistResponseItemForMemories(message)) {
-			messages.push(message);
+			messages.push(dropThinkingContentForMemories(message));
 		}
 	}
 	return messages;
 }
 
+/**
+ * Drop `thinking`/`redactedThinking` content blocks from an assistant message
+ * before it is JSON-serialized into the stage-one extraction prompt. The raw
+ * message object (not just its extracted text) is embedded verbatim as
+ * `response_items_json` in `stage_one_input.md`, so any reasoning block left
+ * in `content` would be replayed as plaintext JSON back to the model — a
+ * documented Anthropic `reasoning_extraction` refusal trigger. Dropped, not
+ * reformatted (mirrors `hindsight/transcript.ts` and `compaction/utils.ts`).
+ */
+function dropThinkingContentForMemories(message: AgentMessage): AgentMessage {
+	const role = (message as { role?: string }).role;
+	if (role !== "assistant") return message;
+	const content = (message as { content?: unknown }).content;
+	if (!Array.isArray(content)) return message;
+	const filtered = content.filter(block => {
+		const type = (block as { type?: string }).type;
+		return type !== "thinking" && type !== "redactedThinking";
+	});
+	if (filtered.length === content.length) return message;
+	return { ...message, content: filtered } as AgentMessage;
+}
+
 async function runStage1Job(options: {
 	claim: Stage1Claim;
 	model: Model;

package/src/modes/acp/acp-agent.ts

@@ -177,6 +177,8 @@ type ReplayableMessage = {
 	toolName?: string;
 	details?: unknown;
 	isError?: boolean;
+	/** `custom`/`hookMessage` visibility flag; absent (e.g. `user`/`developer`) means no gate. */
+	display?: boolean;
 };
 
 type ReplayableToolItem = {
@@ -1906,12 +1908,16 @@ export class AcpAgent implements Agent {
 		if (message.role === "assistant") {
 			return this.#replayAssistantMessage(sessionId, message, cwd, replayedToolCallIds, replayedToolCallArgs);
 		}
-		if (
-			message.role === "user" ||
-			message.role === "developer" ||
-			message.role === "custom" ||
-			message.role === "hookMessage"
-		) {
+		// `developer` carries jeopi-internal reminders/nudges (e.g. `<system-reminder>`
+		// todo nudges) — the TUI never renders these (blanked to empty text in both the
+		// live and history-rebuild paths; see chat-transcript-builder.ts / ui-helpers.ts),
+		// so ACP replay must not surface them to the client either. `custom`/`hookMessage`
+		// carry the same `display` gate the TUI checks (`#appendCustomMessage` /
+		// ui-helpers.ts's `if (message.display)`) — a hidden one (e.g. the resolve-preview
+		// reminder, the todo-error reminder) must stay hidden on replay too.
+		const replayableAsUserChunk =
+			message.role === "user" || ((message.role === "custom" || message.role === "hookMessage") && message.display);
+		if (replayableAsUserChunk) {
 			return this.#wrapReplayContent(
 				sessionId,
 				this.#extractReplayContent(message.content, undefined),

package/src/modes/controllers/selector-controller.ts

@@ -4,7 +4,7 @@ import { getOAuthProviders } from "jeopi-ai/oauth";
 import type { OAuthProvider } from "jeopi-ai/oauth/types";
 import type { Component, OverlayHandle } from "jeopi-tui";
 import { Input, Loader, Spacer, setTuiTight, Text } from "jeopi-tui";
-import { getAgentDbPath, getAgentDir, getProjectDir, normalizePathForComparison } from "jeopi-utils";
+import { formatNumber, getAgentDbPath, getAgentDir, getProjectDir, normalizePathForComparison } from "jeopi-utils";
 import {
 	type AdvisorConfigScope,
 	discoverAdvisorConfigs,
@@ -633,8 +633,22 @@ export class SelectorController {
 							if (switched) {
 								this.ctx.statusLine.invalidate();
 								this.ctx.updateEditorBorderColor();
+								this.ctx.showStatus(`Default model: ${selector ?? model.id}`);
+							} else {
+								// `setModel` deliberately skips the live switch (while still
+								// persisting the role) when the session's current context token
+								// count already exceeds the candidate's context window — sending
+								// on that model would just fail with a context-overflow error.
+								// This is exactly the moment a user hits a usage/token limit and
+								// reaches for /model to escape it, so the picker must say the
+								// active model did NOT change instead of the generic success
+								// status — otherwise the switch looks silently ignored.
+								this.ctx.showError(
+									`Default model set to ${selector ?? model.id} for future sessions, but NOT applied now: ` +
+										`current context (${formatNumber(currentContextTokens)} tokens) exceeds its ` +
+										`${formatNumber(model.contextWindow ?? 0)}-token window. Compact (/compact) or start a new session to switch now.`,
+								);
 							}
-							this.ctx.showStatus(`Default model: ${selector ?? model.id}`);
 							// Don't call done() - selector stays open for role assignment
 						} else {
 							// Other roles (smol, slow): just update settings, not current model

package/src/prompts/advisor/system.md

@@ -13,7 +13,7 @@ Look where the agent is NOT — bring the angle they skipped, NEVER re-run reaso
 Offer that view before they sink work into the wrong direction.
 
 <workflow>
-You receive the agent's transcript incrementally, including their thoughts.
+You receive the agent's transcript incrementally — their messages, tool calls, and results.
 Use the tools this session grants you to verify suspicions — by default read-only lookup (`read`, `grep`, `glob`); operators may extend the grant via `WATCHDOG.yml`. Advising is your primary channel; touch mutating tools (when granted) only when a verify step genuinely needs them.
 Keep exploration lean:
 - 2–3 tool calls per advise.

package/src/prompts/system/interrupted-thinking.md

@@ -1,7 +1,6 @@
 <system-notice type="interrupted-thinking">
-Your previous turn was interrupted while you were thinking.
-- You MUST treat the preserved reasoning as internal continuity context.
-- You MUST continue the user's task from the relevant unfinished point.
+Your previous turn was cut off before you finished. Below is your unfinished internal work state — use it silently to resume; do not quote, repeat, or restate it back.
+- Continue the user's task from the relevant unfinished point.
 ------
 {{reasoning}}
 </system-notice>

package/src/session/agent-session.ts

@@ -1472,17 +1472,6 @@ function textFromContent(content: unknown): string {
 	return parts.join("\n\n");
 }
 
-function thinkingFromContent(content: unknown): string {
-	if (!Array.isArray(content)) return "";
-	const parts: string[] = [];
-	for (const block of content) {
-		if (!isRecord(block) || block.type !== "thinking" || typeof block.thinking !== "string") continue;
-		const thinking = block.thinking.trim();
-		if (thinking) parts.push(thinking);
-	}
-	return parts.join("\n\n");
-}
-
 function toolCallOpFromMessage(message: AgentMessage, toolCallId: string): string | undefined {
 	if (message.role !== "assistant" || !Array.isArray(message.content)) return undefined;
 	for (const block of message.content) {
@@ -1492,12 +1481,21 @@ function toolCallOpFromMessage(message: AgentMessage, toolCallId: string): strin
 	return undefined;
 }
 
+/**
+ * Title context turns carry `text` only — no `thinking`. The replan-refresh
+ * title model resolves through the `tiny`/`commit`/`smol` roles but falls back
+ * to the session's own current model (`getTitleModel` in title-generator.ts)
+ * when no such role is configured, which can be the same Anthropic model the
+ * primary turn used. Replaying prior assistant thinking as plaintext back to
+ * that model is a `reasoning_extraction` classifier-refusal trigger (see the
+ * intentional thinking-drop in compaction/utils.ts, memories/index.ts, and the
+ * hindsight/mnemopi transcript extractor) — dropped here for the same reason.
+ */
 function titleConversationTurnFromMessage(message: AgentMessage): TitleConversationTurn | undefined {
 	if (message.role !== "user" && message.role !== "assistant") return undefined;
 	const text = textFromContent(message.content);
-	const thinking = message.role === "assistant" ? thinkingFromContent(message.content) : undefined;
-	if (!text && !thinking) return undefined;
-	return { role: message.role, ...(text ? { text } : {}), ...(thinking ? { thinking } : {}) };
+	if (!text) return undefined;
+	return { role: message.role, text };
 }
 
 export class AgentSession {
@@ -1593,6 +1591,14 @@ export class AgentSession {
 	#retryAttempt = 0;
 	/** Rung-4 classifier-refusal resend streak (post fallback-ladder). */
 	#refusalBackoff: { startedAt: number; attempt: number } | undefined = undefined;
+	/**
+	 * One-shot latch: `reasoning_extraction` classifier refusals are payload-shape-bound
+	 * (see advisor/runtime.ts `#includeThinking` degrade) — resending the identical batch
+	 * predictably re-refuses. Set the first time `#handleRetryableError` strips unsigned
+	 * thinking/redactedThinking from active context and resends on the same model; never
+	 * reset, mirroring the advisor's permanent-for-the-session degrade.
+	 */
+	#reasoningExtractionDegraded = false;
 	#retryPromise: Promise<void> | undefined = undefined;
 	#retryResolve: (() => void) | undefined = undefined;
 	#activeRetryFallback: ActiveRetryFallbackState | undefined = undefined;
@@ -12681,6 +12687,36 @@ export class AgentSession {
 		const stopType = message.stopDetails?.type;
 		return stopType === "refusal" || stopType === "sensitive";
 	}
+	/**
+	 * Strip unsigned `thinking` and every `redactedThinking` block from assistant
+	 * messages. Used once as a `reasoning_extraction` classifier-refusal degrade:
+	 * unlike {@link renderDemotedThinking}'s plain-text fallback (still a plaintext
+	 * reasoning replay for dialects outside the Fable/Mythos carve-out), dropping the
+	 * block outright removes the trigger instead of reformatting it. Signed thinking
+	 * is left untouched — it replays natively via the provider's structured thinking
+	 * block and is never demoted to plaintext.
+	 * @returns a rewritten array, or `undefined` if no message needed stripping.
+	 */
+	#stripUnsignedThinkingForRefusalDegrade(messages: readonly AgentMessage[]): AgentMessage[] | undefined {
+		let changed = false;
+		const next: AgentMessage[] = [];
+		for (const message of messages) {
+			if (message.role !== "assistant") {
+				next.push(message);
+				continue;
+			}
+			const content = message.content.filter(
+				block => block.type !== "redactedThinking" && (block.type !== "thinking" || !!block.thinkingSignature),
+			);
+			if (content.length === message.content.length) {
+				next.push(message);
+				continue;
+			}
+			changed = true;
+			if (content.length > 0) next.push({ ...message, content });
+		}
+		return changed ? next : undefined;
+	}
 
 	#getRetryFallbackChains(): RetryFallbackChains {
 		const configuredChains = this.settings.get("retry.fallbackChains");
@@ -13099,6 +13135,33 @@ export class AgentSession {
 		}
 
 		const errorMessage = message.errorMessage || "Unknown error";
+		// `reasoning_extraction` is payload-shape-bound (see advisor/runtime.ts): resending
+		// the identical batch predictably re-refuses, unlike probabilistic classifier flags
+		// where backoff/fallback genuinely help. Degrade once — strip unsigned
+		// thinking/redactedThinking from active context and resend immediately on the same
+		// model — before falling through to the generic fallback-pin / backoff ladder below,
+		// which would otherwise retry the unchanged, re-refusing payload.
+		if (
+			classifierRefusal &&
+			message.stopDetails?.category === "reasoning_extraction" &&
+			!this.#reasoningExtractionDegraded
+		) {
+			this.#reasoningExtractionDegraded = true;
+			const stripped = this.#stripUnsignedThinkingForRefusalDegrade(this.agent.state.messages);
+			if (stripped) this.agent.replaceMessages(stripped);
+			this.#removeAssistantMessageFromActiveContext(message, "reasoning-extraction-degrade");
+			await this.#emitSessionEvent({
+				type: "auto_retry_start",
+				attempt: this.#retryAttempt,
+				maxAttempts: retrySettings.maxRetries,
+				delayMs: 0,
+				errorMessage,
+				errorId: message.errorId,
+			});
+			this.#scheduleAgentContinue({ delayMs: 1, generation });
+			return true;
+		}
+
 		const id = this.#classifyRetryMessage(message);
 		const staleOpenAIResponsesReplayError = AIError.is(id, AIError.Flag.StaleResponsesItem);
 		const parsedRetryAfterMs = this.#parseRetryAfterMsFromError(errorMessage);
@@ -15130,7 +15193,7 @@ export class AgentSession {
 	 * @returns Path to exported file
 	 */
 	async exportToHtml(outputPath?: string): Promise<string> {
-		// Public HTML export ships in the omp brand palette (collab-web
+		// Public HTML export ships in the jeopi brand palette (collab-web
 		// pink/purple), matching my.omp.sh — not the host's terminal theme.
 		// Callers who want a themed export can pass `palette: "theme"` with
 		// `themeName` directly to `exportSessionToHtml`.

package/src/tiny/text.ts

@@ -47,20 +47,23 @@ export function formatTitleUserMessage(message: string): string {
 export interface TitleConversationTurn {
 	role: "user" | "assistant";
 	text?: string;
-	thinking?: string;
 }
 
-/** Format recent user/assistant context for title generation after a todo replan. */
+/**
+ * Format recent user/assistant context for title generation after a todo
+ * replan. Assistant `thinking` is intentionally never included: the
+ * replan-refresh title model falls back to the session's own current model
+ * when no `tiny`/`commit`/`smol` role is configured, so replaying prior
+ * reasoning as plaintext here is a `reasoning_extraction` classifier-refusal
+ * trigger on Anthropic targets (mirrors the thinking-drop in compaction,
+ * memories, and the hindsight transcript extractor).
+ */
 export function formatTitleConversationContext(turns: readonly TitleConversationTurn[]): string {
 	const formattedTurns: string[] = [];
 	for (const turn of turns) {
-		const sections: string[] = [];
 		const text = turn.text?.trim();
-		if (text) sections.push(text);
-		const thinking = turn.role === "assistant" ? turn.thinking?.trim() : undefined;
-		if (thinking) sections.push(`<thinking>\n${thinking}\n</thinking>`);
-		if (sections.length === 0) continue;
-		formattedTurns.push(`<${turn.role}>\n${sections.join("\n\n")}\n</${turn.role}>`);
+		if (!text) continue;
+		formattedTurns.push(`<${turn.role}>\n${text}\n</${turn.role}>`);
 	}
 	if (formattedTurns.length === 0) return "";
 	return prepareTitleInput(`<conversation>\n${formattedTurns.join("\n\n")}\n</conversation>`);

package/src/tools/image-gen.ts

@@ -1,7 +1,7 @@
 import * as os from "node:os";
 import * as path from "node:path";
 import { type } from "arktype";
-import { type ApiKey, type FetchImpl, getEnvApiKey, type Model, withAuth } from "jeopi-ai";
+import { type ApiKey, type FetchImpl, getEnvApiKey, getOpenRouterHeaders, type Model, withAuth } from "jeopi-ai";
 import { ProviderHttpError } from "jeopi-ai/error";
 import {
 	CODEX_BASE_URL,
@@ -1394,9 +1394,7 @@ export const imageGenTool: CustomTool<typeof imageGenSchema, ImageGenToolDetails
 							headers: {
 								"Content-Type": "application/json",
 								Authorization: `Bearer ${key}`,
-								"HTTP-Referer": "https://omp.sh/",
-								"X-OpenRouter-Title": "Oh-My-Pi",
-								"X-OpenRouter-Categories": "cli-agent",
+								...getOpenRouterHeaders(),
 							},
 							body: JSON.stringify(requestBody),
 							signal: requestSignal,

package/src/tools/report-tool-issue.ts

@@ -13,7 +13,7 @@
  * (including from subagents) read the cached decision without prompting.
  *
  * When the user grants consent, push is automatically active against the
- * bundled endpoint (`dev.autoqaPush.endpoint`, default `qa.omp.sh`). Each
+ * bundled endpoint (`dev.autoqaPush.endpoint`, default `qa.jeopi.sh`). Each
  * insert schedules a background flush that POSTs pending rows and deletes
  * them on HTTP 2xx. `PI_AUTO_QA_PUSH=1` forces push in non-interactive
  * environments where the consent dialog never fires. Tool execution is