jeopi-cli 16.2.27 → 16.2.29

package/dist/types/advisor/runtime.d.ts

@@ -19,6 +19,9 @@ export interface AdvisorAgent {
     readonly state: {
         messages: AgentMessage[];
         error?: string;
+        model?: {
+            id: string;
+        };
     };
 }
 export interface AdvisorRuntimeHost {

package/dist/types/session/session-history-format.d.ts

@@ -3,6 +3,18 @@ export interface HistoryFormatOptions {
     title?: string;
     /** Render assistant thinking blocks (default: elided). */
     includeThinking?: boolean;
+    /**
+     * When rendering thinking (requires `includeThinking`), disguise it through
+     * {@link renderDemotedThinking} for this target model id instead of the literal
+     * `_thinking:_ ` label. Anthropic's `reasoning_extraction` classifier can flag a
+     * transcript that replays a *different* model's prior thinking back at a
+     * Fable/Mythos model labeled as "thinking" — this is the same trigger
+     * `renderDemotedThinking` already avoids for cross-model/cross-turn replay in the
+     * wire layer. Omitted for the human-facing `history://` dump, where the explicit
+     * label is more useful than the disguise and there is no live model on the other
+     * end to refuse it.
+     */
+    demoteThinkingForModelId?: string;
     /** Render tool intent comment before tool call lines. */
     includeToolIntent?: boolean;
     /** Render watched-session roles as inline `**agent**:` / `**user**:` labels (collapsing consecutive same-role messages) instead of `## ` headings, so a primary transcript embedded inside an advisor turn stays visually distinct. */

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "jeopi-cli",
-	"version": "16.2.27",
+	"version": "16.2.29",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/akillness/jeopi",
 	"author": "Can Boluk",
@@ -43,6 +43,7 @@
 		"gen:docs": "bun scripts/generate-docs-index.ts --generate",
 		"gen:docs:reset": "bun scripts/generate-docs-index.ts --reset",
 		"gen:tool-views": "bun --cwd=../collab-web run gen:tool-views",
+		"gen:share-viewer": "bun scripts/generate-share-viewer.ts",
 		"gen:bundle": "bun scripts/bundle-dist.ts",
 		"gen:mupdf": "bun scripts/embed-mupdf-wasm.ts --generate",
 		"gen:mupdf:reset": "bun scripts/embed-mupdf-wasm.ts --reset",
@@ -56,17 +57,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"jeopi-hashline": "16.2.27",
-		"jeopi-stats": "16.2.27",
-		"jeopi-agent-core": "16.2.27",
-		"jeopi-ai": "16.2.27",
-		"jeopi-catalog": "16.2.27",
-		"jeopi-mnemopi": "16.2.27",
-		"jeopi-natives": "16.2.27",
-		"jeopi-tui": "16.2.27",
-		"jeopi-utils": "16.2.27",
-		"jeopi-wire": "16.2.27",
-		"jeopi-snapcompact": "16.2.27",
+		"jeopi-hashline": "16.2.29",
+		"jeopi-stats": "16.2.29",
+		"jeopi-agent-core": "16.2.29",
+		"jeopi-ai": "16.2.29",
+		"jeopi-catalog": "16.2.29",
+		"jeopi-mnemopi": "16.2.29",
+		"jeopi-natives": "16.2.29",
+		"jeopi-tui": "16.2.29",
+		"jeopi-utils": "16.2.29",
+		"jeopi-wire": "16.2.29",
+		"jeopi-snapcompact": "16.2.29",
 		"@opentelemetry/api": "^1.9.1",
 		"@opentelemetry/context-async-hooks": "^2.7.1",
 		"@opentelemetry/exporter-trace-otlp-proto": "^0.218.0",

package/src/advisor/__tests__/advisor.test.ts

@@ -1381,6 +1381,49 @@ describe("advisor", () => {
 			expect(strippedNotices).toHaveLength(1);
 		});
 
+		it("never sends the literal reasoning_extraction-triggering label when the advisor's own model is Fable/Mythos (no refusal, no degrade)", async () => {
+			const promptInputs: string[] = [];
+			const strippedNotices: number[] = [];
+			const agent: AdvisorAgent = {
+				prompt: async input => {
+					promptInputs.push(input);
+				},
+				abort: () => {},
+				reset: () => {},
+				state: { messages: [], model: { id: "claude-fable-5" } },
+			};
+			const thinking = "secret chain of thought the classifier flags";
+			const messages: AgentMessage[] = [
+				{ role: "user", content: "do the thing", timestamp: 1 } as AgentMessage,
+				{
+					role: "assistant",
+					content: [
+						{ type: "thinking", thinking },
+						{ type: "text", text: "done" },
+					],
+					timestamp: 2,
+				} as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				notifyThinkingStripped: () => strippedNotices.push(1),
+			};
+			const runtime = new AdvisorRuntime(agent, host, 0);
+
+			runtime.onTurnEnd(messages);
+			await runtime.waitForCatchup(5000, 1);
+
+			// Sent once, on the first attempt — the disguised form carries the
+			// reasoning content but never the literal "_thinking:_" label, so
+			// there is nothing for the classifier to catch and no degrade fires.
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).not.toContain("_thinking:_");
+			expect(promptInputs[0]).toContain(thinking);
+			expect(strippedNotices).toHaveLength(0);
+			expect(runtime.backlog).toBe(0);
+		});
+
 		it("skips the degrade path when thinking is disabled at construction and falls through to the watchdog", async () => {
 			const promptInputs: string[] = [];
 			const strippedNotices: number[] = [];

package/src/advisor/runtime.ts

@@ -21,7 +21,7 @@ export interface AdvisorAgent {
 	 * turn `Agent.#runLoop` records on its internal state.
 	 */
 	rollbackTo?(count: number): void;
-	readonly state: { messages: AgentMessage[]; error?: string };
+	readonly state: { messages: AgentMessage[]; error?: string; model?: { id: string } };
 }
 
 export interface AdvisorRuntimeHost {
@@ -116,7 +116,12 @@ export class AdvisorRuntime {
 	 * `false` exactly once, the first time a classifier refusal is caught — see
 	 * the `#drain` catch block. That single flip is sufficient to both change
 	 * future renders AND guard against re-triggering the degrade path, so no
-	 * separate one-shot flag is needed alongside it.
+	 * separate one-shot flag is needed alongside it. When the render target is a
+	 * Fable/Mythos model, {@link formatSessionHistoryMarkdown}'s
+	 * `demoteThinkingForModelId` (wired from `agent.state.model.id` in
+	 * {@link AdvisorRuntime.#renderDelta}) already disguises the rendered thinking
+	 * before the first send, so this latch mainly guards other/unforeseen
+	 * classifier triggers on the first turn.
 	 */
 	#includeThinking: boolean;
 
@@ -243,6 +248,7 @@ export class AdvisorRuntime {
 		const formattedDelta = obfuscator?.hasSecrets() ? obfuscateAdvisorDelta(obfuscator, delta) : delta;
 		const md = formatSessionHistoryMarkdown(formattedDelta, {
 			includeThinking: this.#includeThinking,
+			demoteThinkingForModelId: this.agent.state.model?.id,
 			includeToolIntent: true,
 			watchedRoles: true,
 			expandPrimaryContext: true,

package/src/config/model-registry.ts

@@ -156,6 +156,17 @@ const AUTHORITATIVE_RUNTIME_CATALOG_PROVIDERS = new Set<string>(
 	),
 );
 
+function isAuthoritativeLocalDiscovery(providerConfig: DiscoveryProviderConfig): boolean {
+	switch (providerConfig.discovery.type) {
+		case "ollama":
+		case "llama.cpp":
+		case "lm-studio":
+			return true;
+		default:
+			return false;
+	}
+}
+
 function isAuthoritativeProjectCatalogModel(model: Model<Api>): boolean {
 	return (
 		model.provider === "google-vertex" &&
@@ -1334,7 +1345,21 @@ export class ModelRegistry {
 			this.#discoverBuiltInProviderModels(strategy, providerFilter),
 		]);
 		const discovered = [...configuredDiscovered, ...builtInDiscovery.models];
-		if (discovered.length === 0 && builtInDiscovery.authoritativeProviders.size === 0) {
+		const successfulAuthoritativeDiscoverableProviders = new Set<string>();
+		for (const providerConfig of selectedDiscoverableProviders) {
+			if (!isAuthoritativeLocalDiscovery(providerConfig)) {
+				continue;
+			}
+			const state = this.#providerDiscoveryStates.get(providerConfig.provider);
+			if (state && (state.status === "ok" || state.status === "empty") && !state.stale) {
+				successfulAuthoritativeDiscoverableProviders.add(providerConfig.provider);
+			}
+		}
+		if (
+			discovered.length === 0 &&
+			builtInDiscovery.authoritativeProviders.size === 0 &&
+			successfulAuthoritativeDiscoverableProviders.size === 0
+		) {
 			return;
 		}
 		const discoveredModels = this.#applyHardcodedModelPolicies(
@@ -1350,6 +1375,9 @@ export class ModelRegistry {
 		for (const provider of builtInDiscovery.authoritativeProviders) {
 			authoritativeProviders.add(provider);
 		}
+		for (const provider of successfulAuthoritativeDiscoverableProviders) {
+			authoritativeProviders.add(provider);
+		}
 		const baseModels =
 			authoritativeProviders.size > 0 ? dropProviderModels(this.#models, authoritativeProviders) : this.#models;
 		const resolved = this.#mergeResolvedModels(baseModels, discoveredModels);
@@ -1385,9 +1413,9 @@ export class ModelRegistry {
 		const cacheProviderId = this.#configuredDiscoveryCacheProviderId(providerConfig);
 		const cached = readModelCache<Api>(cacheProviderId, 24 * 60 * 60 * 1000, Date.now, this.#cacheDbPath);
 		const cacheOlderThanConfig = cached !== null && this.#isDiscoveryCacheOlderThanModelsConfig(cached.updatedAt);
-		const bypassFreshCache = providerConfig.discovery.type === "llama.cpp" && strategy === "online-if-uncached";
-		const effectiveStrategy =
-			strategy === "online-if-uncached" && (cacheOlderThanConfig || bypassFreshCache) ? "online" : strategy;
+		const shouldForceOnlineDiscovery =
+			strategy === "online-if-uncached" && (cacheOlderThanConfig || isAuthoritativeLocalDiscovery(providerConfig));
+		const effectiveStrategy = shouldForceOnlineDiscovery ? "online" : strategy;
 		const requiresAuth = !this.#keylessProviders.has(providerConfig.provider);
 		if (requiresAuth) {
 			const apiKey = await this.#peekApiKeyForProvider(providerConfig.provider);
@@ -1450,7 +1478,10 @@ export class ModelRegistry {
 			provider: providerId,
 			status,
 			optional: providerConfig.optional ?? false,
-			stale: result.stale || status === "cached" || ((cacheOlderThanConfig || bypassFreshCache) && status !== "ok"),
+			stale:
+				result.stale ||
+				status === "cached" ||
+				(shouldForceOnlineDiscovery && status !== "ok" && status !== "empty"),
 			fetchedAt: discoveryError ? cached?.updatedAt : Date.now(),
 			models: result.models.map(model => model.id),
 			error: discoveryError,
@@ -1627,7 +1658,9 @@ export class ModelRegistry {
 	): Promise<BuiltInDiscoveryResult> {
 		try {
 			const manager = createModelManager({ ...options, cacheDbPath: this.#cacheDbPath });
-			const result = await manager.refresh(strategy);
+			const effectiveStrategy =
+				strategy === "online-if-uncached" && options.providerId === "lm-studio" ? "online" : strategy;
+			const result = await manager.refresh(effectiveStrategy);
 			const models = result.models.map(model =>
 				model.provider === options.providerId ? model : { ...model, provider: options.providerId },
 			);