@oh-my-pi/pi-coding-agent 16.1.14 → 16.1.15

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

@@ -1,4 +1,5 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
+import { type SecretObfuscator } from "../secrets/obfuscator";
 /** Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core `Agent`. */
 export interface AdvisorAgent {
     prompt(input: string): Promise<void>;
@@ -13,6 +14,8 @@ export interface AdvisorRuntimeHost {
     snapshotMessages(): AgentMessage[];
     /** Surface one advice note to the primary (enqueues into the session YieldQueue). */
     enqueueAdvice(note: string, severity?: "nit" | "concern" | "blocker"): void;
+    /** Redact primary transcript bytes before they reach the advisor model. */
+    obfuscator?: SecretObfuscator;
     /**
      * Pre-prompt context maintenance for the advisor's own append-only context.
      * Promotes the advisor model to a larger sibling when its context nears the

package/dist/types/config/settings-schema.d.ts

@@ -1636,6 +1636,26 @@ export declare const SETTINGS_SCHEMA: {
             readonly description: "Share viewer/upload base used by /share (encrypted blob upload + viewer; links are <base>/<id>#<key>)";
         };
     };
+    readonly "share.store": {
+        readonly type: "enum";
+        readonly values: readonly ["blob", "gist"];
+        readonly default: "blob";
+        readonly ui: {
+            readonly tab: "interaction";
+            readonly group: "Collab";
+            readonly label: "Share Store";
+            readonly description: "Where /share uploads the encrypted session blob";
+            readonly options: readonly [{
+                readonly value: "blob";
+                readonly label: "Encrypted Blob";
+                readonly description: "Upload to the share server (no GitHub account needed; avoids gist API rate limits)";
+            }, {
+                readonly value: "gist";
+                readonly label: "GitHub Gist";
+                readonly description: "Push to a secret gist (needs authenticated gh), falling back to the share server";
+            }];
+        };
+    };
     readonly "share.redactSecrets": {
         readonly type: "boolean";
         readonly default: true;

package/dist/types/export/share.d.ts

@@ -6,9 +6,16 @@ import { type SessionData } from "./html";
 export { DEFAULT_SHARE_URL };
 /** Hard cap for blobs accepted by the share server (mirrors relay shareMaxBytes). */
 export declare const SERVER_MAX_SEALED_BYTES = 1000000;
+export type ShareStore = "blob" | "gist";
 export interface ShareSessionOptions {
     /** Share server/viewer base URL; defaults to {@link DEFAULT_SHARE_URL}. */
     serverUrl?: string;
+    /**
+     * Where to upload the sealed blob. `"blob"` (default) posts to the share
+     * server; `"gist"` pushes to a secret GitHub gist first (needs an
+     * authenticated `gh`) and falls back to the server.
+     */
+    store?: ShareStore;
     /** Agent state for system prompt + tool descriptions in the snapshot. */
     state?: AgentState;
     /**
@@ -36,7 +43,7 @@ export interface ShareSessionResult {
 }
 /** Build the snapshot that gets sealed and uploaded, redacted when an obfuscator is provided. */
 export declare function buildShareSnapshot(sm: SessionManager, options?: ShareSessionOptions): SessionData;
-/** Share the session; tries a secret gist first, then the share server. */
+/** Share the session; uploads to the share server unless `options.store` is `"gist"`. */
 export declare function shareSession(sm: SessionManager, options?: ShareSessionOptions): Promise<ShareSessionResult>;
 /** Strip trailing slashes so `<base>/<id>` composes cleanly. */
 export declare function normalizeShareServerUrl(serverUrl?: string): string;

package/dist/types/mcp/transports/stdio.d.ts

@@ -16,7 +16,18 @@ export interface ResolveStdioSpawnOptions {
     env: Record<string, string | undefined>;
     platform?: NodeJS.Platform;
 }
-/** Resolve the subprocess argv used to launch an MCP stdio server. */
+/**
+ * Resolve the subprocess argv used to launch an MCP stdio server.
+ *
+ * On Windows, our PATH/PATHEXT walk may return `null` for a bare command
+ * (e.g. `npx`) — `Bun.env.PATH` empty under a restricted parent process,
+ * UNC/network mounts that reject `fs.access`, locked-down shells. The
+ * legacy fallback handed `Bun.spawn` the bare name, but `CreateProcess`
+ * only appends `.exe` for extensionless names — `.cmd`/`.bat` are never
+ * tried, so `npx` (which exists only as `npx.cmd` on Windows) crashes the
+ * subprocess immediately. When the resolver can't pin the command down,
+ * route through `cmd.exe /d /s /c` so Windows's own PATHEXT lookup runs.
+ */
 export declare function resolveStdioSpawnCommand(config: MCPStdioServerConfig, options: ResolveStdioSpawnOptions): Promise<StdioSpawnCommand>;
 /** Minimal write surface of `Subprocess.stdin` we need for framed sends. */
 interface FrameSink {

package/dist/types/modes/components/status-line/context-thresholds.d.ts

@@ -2,8 +2,9 @@ import type { ThemeColor } from "../../../modes/theme/theme";
 export type ContextUsageLevel = "normal" | "warning" | "purple" | "error";
 export declare function getContextUsageLevel(contextPercent: number, contextWindow: number): ContextUsageLevel;
 /**
- * Format context usage as `<percent>%/<window>` (e.g. `5.1%/1M`), matching the
- * status line's context gauge so subagent and footer renderers stay in sync.
+ * Format context usage as `<percent>%/<window>` when the model window is known.
+ * Unknown windows render as `<tokens>/?`, because `0.0%/0` suggests a real
+ * empty context instead of missing provider metadata.
  */
-export declare function formatContextUsage(contextPercent: number | null | undefined, contextWindow: number): string;
+export declare function formatContextUsage(contextPercent: number | null | undefined, contextWindow: number, usedTokens?: number): string;
 export declare function getContextUsageThemeColor(level: ContextUsageLevel): ThemeColor;

package/dist/types/modes/components/status-line/types.d.ts

@@ -72,6 +72,7 @@ export interface SegmentContext {
     };
     /** Context usage percent, or null when unknown (e.g. right after compaction). */
     contextPercent: number | null;
+    contextTokens: number;
     contextWindow: number;
     autoCompactEnabled: boolean;
     subagentCount: number;

package/dist/types/secrets/obfuscator.d.ts

@@ -34,9 +34,9 @@ export declare class SecretObfuscator {
 export declare function deobfuscateSessionContext(sessionContext: SessionContext, obfuscator: SecretObfuscator | undefined): SessionContext;
 export declare function deobfuscateAgentMessages(obfuscator: SecretObfuscator, messages: AgentMessage[]): AgentMessage[];
 /**
- * Restore placeholders in assistant content: visible text, thinking text, and
- * tool-call arguments/intent/rawBlock. Signatures and redacted-thinking bytes
- * are opaque provider-replay data and pass through byte-identical.
+ * Restore placeholders in assistant content: visible text and tool-call
+ * arguments/intent/rawBlock. Thinking and signatures are opaque
+ * provider-replay/hidden-reasoning data and pass through byte-identical.
  */
 export declare function deobfuscateAssistantContent(obfuscator: SecretObfuscator, content: AssistantMessage["content"]): AssistantMessage["content"];
 /**

package/dist/types/utils/shell-snapshot.d.ts

@@ -1,3 +1,13 @@
+/**
+ * Strip alias definitions brush's whitespace-only expander cannot execute.
+ *
+ * Returns the rewritten snapshot plus the list of dropped alias names so the
+ * caller can surface them in the debug log.
+ */
+export declare function sanitizeSnapshotForBrush(content: string): {
+    content: string;
+    dropped: string[];
+};
 /**
  * Create a shell snapshot, caching the result.
  * Returns the path to the snapshot file, or null if creation failed.

package/dist/types/web/search/providers/perplexity.d.ts

@@ -33,11 +33,25 @@ export declare function searchPerplexity(params: PerplexitySearchParams): Promis
 export declare class PerplexityProvider extends SearchProvider {
     readonly id = "perplexity";
     readonly label = "Perplexity";
+    /**
+     * Auto-chain admission. Requires a direct Perplexity credential
+     * (`PERPLEXITY_COOKIES`, OAuth session, or `PERPLEXITY_API_KEY`).
+     *
+     * OpenRouter auth is intentionally NOT accepted here: silently using
+     * OpenRouter's `perplexity/sonar-pro` whenever any OpenRouter key is
+     * configured surprises users (and bills them) for a path they never
+     * asked for. The auto chain skips Perplexity in that case and falls
+     * through to the next configured provider. Users who DO want the
+     * OpenRouter-backed Perplexity path can still opt in by setting
+     * `webSearch: perplexity` explicitly — see {@link isExplicitlyAvailable}.
+     */
     isAvailable(authStorage: AuthStorage): boolean;
     /**
-     * Perplexity accepts anonymous browser-style ask requests, but keep auto
-     * provider selection credential-gated so a configured provider keeps priority
-     * over the anonymous fallback.
+     * Perplexity accepts anonymous browser-style ask requests, and the
+     * OpenRouter-backed `perplexity/sonar-pro` path is opt-in through
+     * explicit selection. Keep auto-chain admission credential-gated so a
+     * configured provider keeps priority over the anonymous/OpenRouter
+     * fallbacks.
      */
     isExplicitlyAvailable(_authStorage: AuthStorage): boolean;
     search(params: SearchParams): Promise<SearchResponse>;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "16.1.14",
+	"version": "16.1.15",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://omp.sh",
 	"author": "Can Boluk",
@@ -48,17 +48,17 @@
 		"@agentclientprotocol/sdk": "0.25.0",
 		"@babel/parser": "^7.29.7",
 		"@mozilla/readability": "^0.6.0",
-		"@oh-my-pi/hashline": "16.1.14",
-		"@oh-my-pi/omp-stats": "16.1.14",
-		"@oh-my-pi/pi-agent-core": "16.1.14",
-		"@oh-my-pi/pi-ai": "16.1.14",
-		"@oh-my-pi/pi-catalog": "16.1.14",
-		"@oh-my-pi/pi-mnemopi": "16.1.14",
-		"@oh-my-pi/pi-natives": "16.1.14",
-		"@oh-my-pi/pi-tui": "16.1.14",
-		"@oh-my-pi/pi-utils": "16.1.14",
-		"@oh-my-pi/pi-wire": "16.1.14",
-		"@oh-my-pi/snapcompact": "16.1.14",
+		"@oh-my-pi/hashline": "16.1.15",
+		"@oh-my-pi/omp-stats": "16.1.15",
+		"@oh-my-pi/pi-agent-core": "16.1.15",
+		"@oh-my-pi/pi-ai": "16.1.15",
+		"@oh-my-pi/pi-catalog": "16.1.15",
+		"@oh-my-pi/pi-mnemopi": "16.1.15",
+		"@oh-my-pi/pi-natives": "16.1.15",
+		"@oh-my-pi/pi-tui": "16.1.15",
+		"@oh-my-pi/pi-utils": "16.1.15",
+		"@oh-my-pi/pi-wire": "16.1.15",
+		"@oh-my-pi/snapcompact": "16.1.15",
 		"@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

@@ -3,6 +3,7 @@ import type { AgentMessage, AgentTelemetryConfig } from "@oh-my-pi/pi-agent-core
 import { type } from "arktype";
 import { createAdvisorMessageCard } from "../../modes/components/advisor-message";
 import { getThemeByName } from "../../modes/theme/theme";
+import { SecretObfuscator } from "../../secrets/obfuscator";
 import { formatSessionHistoryMarkdown } from "../../session/session-history-format";
 import { YieldQueue } from "../../session/yield-queue";
 import {
@@ -447,6 +448,119 @@ describe("advisor", () => {
 			expect(promptInputs[0]).not.toContain("note");
 		});
 
+		it("obfuscates session updates before prompting the advisor", async () => {
+			const secret = "ADVISOR_SECRET_TOKEN_123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [{ role: "user", content: `token ${secret}`, timestamp: 1 } as AgentMessage];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+		});
+
+		it("redacts expanded primary context before XML escaping", async () => {
+			const secret = "ADVISOR&SECRET<TOKEN>123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [
+				{
+					role: "custom",
+					customType: "plan-mode-context",
+					content: `Plan mode carries ${secret}`,
+					display: false,
+					timestamp: 1,
+				} as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+			expect(promptInputs[0]).not.toContain("ADVISOR&amp;SECRET&lt;TOKEN&gt;123");
+		});
+
+		it("redacts file-mention paths before formatting", async () => {
+			const secret = "MENTION_SECRET_TOKEN_123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [
+				{
+					role: "fileMention",
+					files: [{ path: `notes/${secret}.txt`, content: "ignored" }],
+					timestamp: 1,
+				} as unknown as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+		});
+
+		it("redacts nested async-result job labels before formatting", async () => {
+			const secret = "JOB_LABEL_SECRET_TOKEN_123";
+			const obfuscator = new SecretObfuscator([{ type: "plain", content: secret }]);
+			const placeholder = obfuscator.obfuscate(secret);
+			const promptInputs: string[] = [];
+			const agent = makeAgent(promptInputs);
+			const messages: AgentMessage[] = [
+				{
+					role: "custom",
+					customType: "async-result",
+					content: "",
+					details: { jobs: [{ label: `bash: echo ${secret}`, jobId: "j1" }] },
+					display: true,
+					attribution: "agent",
+					timestamp: 1,
+				} as unknown as AgentMessage,
+			];
+			const host: AdvisorRuntimeHost = {
+				snapshotMessages: () => messages,
+				enqueueAdvice: () => {},
+				obfuscator,
+			};
+			const runtime = new AdvisorRuntime(agent, host);
+
+			runtime.onTurnEnd();
+			await Promise.resolve();
+
+			expect(promptInputs).toHaveLength(1);
+			expect(promptInputs[0]).toContain(placeholder);
+			expect(promptInputs[0]).not.toContain(secret);
+		});
+
 		it("expands plan-mode context once, then collapses an unchanged re-injection", async () => {
 			const promptInputs: string[] = [];
 			const agent = makeAgent(promptInputs);

package/src/advisor/runtime.ts

@@ -1,6 +1,8 @@
 import type { AgentMessage } from "@oh-my-pi/pi-agent-core";
 import { estimateTokens } from "@oh-my-pi/pi-agent-core/compaction";
+import type { AssistantMessage, ImageContent, TextContent } from "@oh-my-pi/pi-ai";
 import { logger } from "@oh-my-pi/pi-utils";
+import { obfuscateToolArguments, type SecretObfuscator } from "../secrets/obfuscator";
 import { formatSessionHistoryMarkdown, PRIMARY_CONTEXT_CUSTOM_TYPES } from "../session/session-history-format";
 
 /** Minimal slice of `Agent` the runtime drives — satisfied by pi-agent-core `Agent`. */
@@ -16,6 +18,8 @@ export interface AdvisorRuntimeHost {
 	snapshotMessages(): AgentMessage[];
 	/** Surface one advice note to the primary (enqueues into the session YieldQueue). */
 	enqueueAdvice(note: string, severity?: "nit" | "concern" | "blocker"): void;
+	/** Redact primary transcript bytes before they reach the advisor model. */
+	obfuscator?: SecretObfuscator;
 	/**
 	 * Pre-prompt context maintenance for the advisor's own append-only context.
 	 * Promotes the advisor model to a larger sibling when its context nears the
@@ -174,7 +178,9 @@ export class AdvisorRuntime {
 			.map(m => this.#dedupContextMessage(m));
 		this.#lastCount = all.length;
 		if (delta.length === 0) return null;
-		const md = formatSessionHistoryMarkdown(delta, {
+		const obfuscator = this.host.obfuscator;
+		const formattedDelta = obfuscator?.hasSecrets() ? obfuscateAdvisorDelta(obfuscator, delta) : delta;
+		const md = formatSessionHistoryMarkdown(formattedDelta, {
 			includeThinking: true,
 			includeToolIntent: true,
 			watchedRoles: true,
@@ -304,3 +310,125 @@ export class AdvisorRuntime {
 		}
 	}
 }
+
+type TextualContent = string | readonly (TextContent | ImageContent)[];
+
+function obfuscateTextualContent(obfuscator: SecretObfuscator, content: TextualContent): TextualContent {
+	if (typeof content === "string") return obfuscator.obfuscate(content);
+	let changed = false;
+	const result = content.map((block): TextContent | ImageContent => {
+		if (block.type !== "text") return block;
+		const text = obfuscator.obfuscate(block.text);
+		if (text === block.text) return block;
+		changed = true;
+		return { ...block, text };
+	});
+	return changed ? result : content;
+}
+
+function obfuscateAssistantMessage(obfuscator: SecretObfuscator, message: AssistantMessage): AssistantMessage {
+	let changed = false;
+	const content = message.content.map((block): AssistantMessage["content"][number] => {
+		if (block.type === "text") {
+			const text = obfuscator.obfuscate(block.text);
+			if (text === block.text) return block;
+			changed = true;
+			return { ...block, text };
+		}
+		if (block.type === "toolCall") {
+			const args = obfuscateToolArguments(obfuscator, block.arguments);
+			if (args === block.arguments) return block;
+			changed = true;
+			return { ...block, arguments: args };
+		}
+		return block;
+	});
+	return changed ? { ...message, content } : message;
+}
+
+function obfuscateDetails(
+	obfuscator: SecretObfuscator,
+	details: Record<string, unknown> | undefined,
+): Record<string, unknown> | undefined {
+	if (!details) return details;
+	// Walk strings at every depth: `customOneLiner` renders nested fields
+	// (e.g. `async-result` reads `details.jobs[].label`/`jobId`), so a shallow
+	// pass leaks any secret a background job's label happens to contain.
+	return obfuscateToolArguments(obfuscator, details);
+}
+
+function obfuscateAdvisorMessage(obfuscator: SecretObfuscator, message: AgentMessage): AgentMessage {
+	switch (message.role) {
+		case "user":
+		case "developer":
+		case "toolResult": {
+			const content = obfuscateTextualContent(obfuscator, message.content as TextualContent);
+			return content === message.content ? message : ({ ...(message as object), content } as AgentMessage);
+		}
+		case "assistant":
+			return obfuscateAssistantMessage(obfuscator, message as AssistantMessage) as AgentMessage;
+		case "custom":
+		case "hookMessage": {
+			const msg = message as AgentMessage & {
+				content: TextualContent;
+				details?: Record<string, unknown>;
+			};
+			const content = obfuscateTextualContent(obfuscator, msg.content);
+			const details = obfuscateDetails(obfuscator, msg.details);
+			if (content === msg.content && details === msg.details) return message;
+			return { ...(message as object), content, details } as AgentMessage;
+		}
+		case "bashExecution": {
+			const msg = message as AgentMessage & { command: string; output: string };
+			const command = obfuscator.obfuscate(msg.command);
+			const output = obfuscator.obfuscate(msg.output);
+			return command === msg.command && output === msg.output
+				? message
+				: ({ ...(message as object), command, output } as AgentMessage);
+		}
+		case "pythonExecution": {
+			const msg = message as AgentMessage & { code: string; output: string };
+			const code = obfuscator.obfuscate(msg.code);
+			const output = obfuscator.obfuscate(msg.output);
+			return code === msg.code && output === msg.output
+				? message
+				: ({ ...(message as object), code, output } as AgentMessage);
+		}
+		case "branchSummary": {
+			const msg = message as AgentMessage & { summary: string };
+			const summary = obfuscator.obfuscate(msg.summary);
+			return summary === msg.summary ? message : ({ ...(message as object), summary } as AgentMessage);
+		}
+		case "compactionSummary": {
+			const msg = message as AgentMessage & { summary: string };
+			const summary = obfuscator.obfuscate(msg.summary);
+			return summary === msg.summary ? message : ({ ...(message as object), summary } as AgentMessage);
+		}
+		case "fileMention": {
+			const msg = message as AgentMessage & {
+				files: Array<{ path: string; content: string; image?: unknown }>;
+			};
+			let changed = false;
+			const files = msg.files.map(file => {
+				const path = obfuscator.obfuscate(file.path);
+				const content = obfuscator.obfuscate(file.content);
+				if (path === file.path && content === file.content) return file;
+				changed = true;
+				return { ...file, path, content };
+			});
+			return changed ? ({ ...(message as object), files } as AgentMessage) : message;
+		}
+		default:
+			return message;
+	}
+}
+
+function obfuscateAdvisorDelta(obfuscator: SecretObfuscator, messages: AgentMessage[]): AgentMessage[] {
+	let changed = false;
+	const result = messages.map(message => {
+		const next = obfuscateAdvisorMessage(obfuscator, message);
+		if (next !== message) changed = true;
+		return next;
+	});
+	return changed ? result : messages;
+}

package/src/config/model-registry.ts

@@ -992,6 +992,7 @@ export class ModelRegistry {
 				});
 				continue;
 			}
+			const configStale = this.#isDiscoveryCacheOlderThanModelsConfig(cache.updatedAt);
 			const models = this.#applyProviderModelOverrides(
 				providerConfig.provider,
 				this.#normalizeDiscoverableModels(
@@ -1007,7 +1008,7 @@ export class ModelRegistry {
 				provider: providerConfig.provider,
 				status: "cached",
 				optional: providerConfig.optional ?? false,
-				stale: !cache.fresh || !cache.authoritative,
+				stale: !cache.fresh || !cache.authoritative || configStale,
 				fetchedAt: cache.updatedAt,
 				models: models.map(model => model.id),
 			});
@@ -1259,12 +1260,19 @@ export class ModelRegistry {
 		return providerConfig.provider;
 	}
 
+	#isDiscoveryCacheOlderThanModelsConfig(cacheUpdatedAt: number): boolean {
+		const configMtime = this.#modelsConfigFile.getMtimeMs();
+		return configMtime !== null && cacheUpdatedAt < Math.floor(configMtime);
+	}
+
 	async #discoverProviderModels(
 		providerConfig: DiscoveryProviderConfig,
 		strategy: ModelRefreshStrategy,
 	): Promise<Model<Api>[]> {
 		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 effectiveStrategy = strategy === "online-if-uncached" && cacheOlderThanConfig ? "online" : strategy;
 		const requiresAuth = !this.#keylessProviders.has(providerConfig.provider);
 		if (requiresAuth) {
 			const apiKey = await this.#peekApiKeyForProvider(providerConfig.provider);
@@ -1311,12 +1319,12 @@ export class ModelRegistry {
 			cacheTtlMs: 24 * 60 * 60 * 1000,
 			fetchDynamicModels,
 		});
-		const result = await manager.refresh(strategy);
+		const result = await manager.refresh(effectiveStrategy);
 		const status = discoveryError
 			? result.models.length > 0
 				? "cached"
 				: "unavailable"
-			: strategy === "offline"
+			: effectiveStrategy === "offline"
 				? cached
 					? "cached"
 					: "idle"
@@ -1327,7 +1335,7 @@ export class ModelRegistry {
 			provider: providerId,
 			status,
 			optional: providerConfig.optional ?? false,
-			stale: result.stale || status === "cached",
+			stale: result.stale || status === "cached" || (cacheOlderThanConfig && status !== "ok"),
 			fetchedAt: discoveryError ? cached?.updatedAt : Date.now(),
 			models: result.models.map(model => model.id),
 			error: discoveryError,

package/src/config/settings-schema.ts

@@ -1592,6 +1592,30 @@ export const SETTINGS_SCHEMA = {
 		},
 	},
 
+	"share.store": {
+		type: "enum",
+		values: ["blob", "gist"] as const,
+		default: "blob",
+		ui: {
+			tab: "interaction",
+			group: "Collab",
+			label: "Share Store",
+			description: "Where /share uploads the encrypted session blob",
+			options: [
+				{
+					value: "blob",
+					label: "Encrypted Blob",
+					description: "Upload to the share server (no GitHub account needed; avoids gist API rate limits)",
+				},
+				{
+					value: "gist",
+					label: "GitHub Gist",
+					description: "Push to a secret gist (needs authenticated gh), falling back to the share server",
+				},
+			],
+		},
+	},
+
 	"share.redactSecrets": {
 		type: "boolean",
 		default: true,

package/src/exec/bash-executor.ts

@@ -59,6 +59,42 @@ const shellSessionQuarantines = new Map<string, Promise<unknown>>();
 /** Session keys with a command currently in flight on the persistent Shell. */
 const shellSessionsInUse = new Set<string>();
 
+/**
+ * Shells retained past their turn because a background (`nohup`/`&`) job is
+ * still running. A per-call `:async:` Shell is normally dropped at teardown,
+ * which SIGKILLs its children via kill-on-drop. Keeping the reference alive lets
+ * the process survive across turns; the Shell is dropped once its last
+ * background job exits (reaped by the poll loop below). Children stay
+ * kill-on-drop, so they still die when the harness tears the Shell down on exit.
+ */
+const retainedShells = new Set<Shell>();
+const RETAIN_REAP_INTERVAL_MS = 5_000;
+
+async function retainShellWithLiveBackgroundJobs(shell: Shell): Promise<void> {
+	let live: number;
+	try {
+		live = await shell.liveBackgroundJobCount();
+	} catch {
+		return;
+	}
+	if (live <= 0) return;
+	retainedShells.add(shell);
+	const interval = setInterval(() => {
+		void shell
+			.liveBackgroundJobCount()
+			.then(remaining => {
+				if (remaining > 0) return;
+				clearInterval(interval);
+				retainedShells.delete(shell);
+			})
+			.catch(() => {
+				clearInterval(interval);
+				retainedShells.delete(shell);
+			});
+	}, RETAIN_REAP_INTERVAL_MS);
+	interval.unref?.();
+}
+
 function quarantineShellSession(
 	sessionKey: string,
 	runPromise: Promise<ShellRunResult>,
@@ -411,6 +447,14 @@ export async function executeBash(command: string, options?: BashExecutorOptions
 				// `:async:` keys are per-job (jobId is unique), so the Shell would
 				// otherwise stay in the process-global map forever after completion.
 				shellSessions.delete(sessionKey);
+				// Dropping the only reference to a per-call `:async:` Shell SIGKILLs
+				// any `nohup`/`&` children (kill-on-drop). If the command left a live
+				// background job, retain the Shell so the process survives across
+				// turns; it is reaped once its last job exits and still dies with the
+				// harness. Skip on resetSession (cancel/error) — those tear down.
+				if (!resetSession && shellSession) {
+					await retainShellWithLiveBackgroundJobs(shellSession);
+				}
 			}
 		}
 	}