@sayknow-cli/coding-agent 0.4.7 → 0.5.0

package/src/config/provider-auth-health.ts

@@ -0,0 +1,42 @@
+import type { AuthStorage } from "@sayknow-cli/ai/auth-storage";
+
+/**
+ * Most recent OAuth validation outcome per provider, used only as an ordering
+ * hint so `/model` can rank a provider whose stored credentials failed
+ * validation below one that is healthy, without re-running validation itself.
+ *
+ * Entries are scoped to the `AuthStorage` that produced them and to its
+ * credential generation, so any login, logout, import, or deletion discards the
+ * stale result instead of overriding current auth state.
+ */
+export type ProviderAuthHealth = "valid" | "invalid";
+
+interface HealthEntry {
+	generation: number;
+	health: ProviderAuthHealth;
+}
+
+const healthByStorage = new WeakMap<AuthStorage, Map<string, HealthEntry>>();
+
+export function recordProviderAuthHealth(
+	authStorage: AuthStorage,
+	providerId: string,
+	health: ProviderAuthHealth,
+): void {
+	let entries = healthByStorage.get(authStorage);
+	if (!entries) {
+		entries = new Map();
+		healthByStorage.set(authStorage, entries);
+	}
+	entries.set(providerId, { generation: authStorage.getGeneration(), health });
+}
+
+export function getProviderAuthHealth(authStorage: AuthStorage, providerId: string): ProviderAuthHealth | undefined {
+	const entry = healthByStorage.get(authStorage)?.get(providerId);
+	if (!entry || entry.generation !== authStorage.getGeneration()) return undefined;
+	return entry.health;
+}
+
+export function clearProviderAuthHealth(authStorage: AuthStorage): void {
+	healthByStorage.delete(authStorage);
+}

package/src/config/provider-ranking.ts

@@ -0,0 +1,119 @@
+/**
+ * Shared provider ordering used by every provider-facing selector (`/login`,
+ * `/model`, `/provider`).
+ *
+ * Providers the user already has come first, then a curated list of well-known
+ * providers, then everything else alphabetically. This is the single source of
+ * truth for that order — surfaces must not keep their own famous-provider list.
+ */
+
+/**
+ * Auth/config state of a provider as seen by the calling surface.
+ *
+ * - `valid` — stored credentials that validated successfully.
+ * - `checking` — stored credentials whose async validation is still in flight.
+ *   Ranked with `valid` so rows do not reflow when validation resolves.
+ * - `configured` — no OAuth record, but the provider is present in the model
+ *   registry with a working API key (custom/API-compatible providers).
+ * - `invalid` — stored credentials that failed validation (problematic login).
+ * - `none` — nothing stored and nothing configured.
+ */
+export type ProviderAuthState = "valid" | "checking" | "configured" | "invalid" | "none";
+
+export const PROVIDER_RANK_TIER = {
+	existing: 0,
+	problematic: 1,
+	famous: 2,
+	other: 3,
+} as const;
+
+export type ProviderRankTier = (typeof PROVIDER_RANK_TIER)[keyof typeof PROVIDER_RANK_TIER];
+
+/**
+ * Curated provider order for the famous tier. Regional and device variants sit
+ * immediately behind their primary so related entries stay grouped.
+ */
+export const FAMOUS_PROVIDER_ORDER: readonly string[] = [
+	"openai-codex",
+	"openai-codex-device",
+	"anthropic",
+	"xai",
+	"opencode-go",
+	"zai",
+	"glm-zcode",
+	"alibaba-token-plan",
+	"qwen-portal",
+	"kimi-code",
+	"moonshot",
+	"minimax-code",
+	"minimax-code-cn",
+	"xiaomi",
+	"xiaomi-token-plan-sgp",
+	"xiaomi-token-plan-ams",
+	"xiaomi-token-plan-cn",
+	"opengateway",
+	"bizrouter",
+	"github-copilot",
+	"cursor",
+];
+
+const FAMOUS_PROVIDER_INDEX = new Map(FAMOUS_PROVIDER_ORDER.map((id, index) => [id, index]));
+
+/** A provider as ranked by a surface. `label` is what the user sees. */
+export interface RankableProvider {
+	id: string;
+	label: string;
+	authState: ProviderAuthState;
+}
+
+/** A provider's position in the ordering: its tier plus its rank inside that tier. */
+export interface ProviderRank {
+	tier: ProviderRankTier;
+	intraTierRank: number;
+}
+
+/**
+ * The single ranking result for a provider. `intraTierRank` is the curated
+ * famous-list position, or `Number.MAX_SAFE_INTEGER` for providers that are not
+ * on the list and therefore order by display label.
+ */
+export function rankProvider(provider: RankableProvider): ProviderRank {
+	return {
+		tier: providerRankTier(provider.authState, provider.id),
+		intraTierRank: FAMOUS_PROVIDER_INDEX.get(provider.id) ?? Number.MAX_SAFE_INTEGER,
+	};
+}
+
+export function providerRankTier(authState: ProviderAuthState, id: string): ProviderRankTier {
+	if (authState === "valid" || authState === "checking" || authState === "configured") {
+		return PROVIDER_RANK_TIER.existing;
+	}
+	if (authState === "invalid") return PROVIDER_RANK_TIER.problematic;
+	return FAMOUS_PROVIDER_INDEX.has(id) ? PROVIDER_RANK_TIER.famous : PROVIDER_RANK_TIER.other;
+}
+
+/** Position within the famous list, or `undefined` for providers not on it. */
+export function famousProviderIndex(id: string): number | undefined {
+	return FAMOUS_PROVIDER_INDEX.get(id);
+}
+
+/**
+ * Total order over providers: tier, then famous-list position, then display
+ * label, then id. The trailing id comparison guarantees no ties.
+ */
+export function compareRankedProviders(left: RankableProvider, right: RankableProvider): number {
+	const leftRank = rankProvider(left);
+	const rightRank = rankProvider(right);
+	if (leftRank.tier !== rightRank.tier) return leftRank.tier - rightRank.tier;
+	if (leftRank.intraTierRank !== rightRank.intraTierRank) return leftRank.intraTierRank - rightRank.intraTierRank;
+
+	const label = left.label.localeCompare(right.label);
+	if (label !== 0) return label;
+
+	return left.id.localeCompare(right.id);
+}
+
+/** Convenience wrapper returning a new array in ranked order. */
+export function sortRankedProviders<T extends RankableProvider>(providers: readonly T[]): T[] {
+	return [...providers].sort(compareRankedProviders);
+}

package/src/config/settings-schema.ts

@@ -313,7 +313,7 @@ export const SETTINGS_SCHEMA = {
 	},
 	"notifications.telegram.toolActivity.enabled": {
 		type: "boolean",
-		default: true,
+		default: false,
 		ui: {
 			tab: "notifications",
 			label: "Telegram Tool Activity",
@@ -506,6 +506,16 @@ export const SETTINGS_SCHEMA = {
 		default: 0.05,
 		validate: (value: number) => Number.isFinite(value) && value > 0 && value <= 1,
 	},
+	"skc.ralplan.maxIterations": {
+		type: "number",
+		default: 5,
+		validate: (value: number) => Number.isInteger(value) && value >= 1 && value <= 20,
+	},
+	"skc.ralplan.maxReviewPassesPerLane": {
+		type: "number",
+		default: 1,
+		validate: (value: number) => Number.isInteger(value) && value >= 1 && value <= 10,
+	},
 
 	// ────────────────────────────────────────────────────────────────────────
 	// Appearance
@@ -845,6 +855,15 @@ export const SETTINGS_SCHEMA = {
 		type: "boolean",
 		default: true,
 	},
+	"statusLine.showActionHints": {
+		type: "boolean",
+		default: true,
+		ui: {
+			tab: "appearance",
+			label: "Status Line Action Hints",
+			description: "Show contextual keyboard shortcuts in the status line",
+		},
+	},
 
 	"statusLine.leftSegments": { type: "array", default: [] as StatusLineSegmentId[] },
 
@@ -1261,7 +1280,8 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "interaction",
 			label: "Mouse Support",
-			description: "Enable SGR mouse wheel scrolling and overlay row selection. Disabled in tmux and screen.",
+			description:
+				"Enable SKC session scrolling, drag-to-copy text selection, and overlay row selection with the mouse. Disabled by default to preserve native terminal or tmux scrollback and selection.",
 		},
 	},
 	// Conversation flow
@@ -1360,6 +1380,16 @@ export const SETTINGS_SCHEMA = {
 			description: "Suggest emojis from `:name:` shortcodes and expand text emoticons like `:D` or `:-)`",
 		},
 	},
+	promptSuggestions: {
+		type: "boolean",
+		default: false,
+		ui: {
+			tab: "interaction",
+			label: "Prompt Suggestions",
+			description:
+				"Predict your likely next prompt after each turn (smol-model call) and show it as ghost text; Tab accepts",
+		},
+	},
 
 	"startup.quiet": {
 		type: "boolean",
@@ -2055,7 +2085,8 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "editing",
 			label: "Default Read Limit",
-			description: "Default number of lines returned when agent calls read without a limit",
+			description:
+				"Default collection/selection limit for read operations; bare local receipts use the separate 50-line / 10 KiB receipt budgets",
 			options: [
 				{ value: "200", label: "200 lines" },
 				{ value: "300", label: "300 lines" },
@@ -2095,6 +2126,22 @@ export const SETTINGS_SCHEMA = {
 			],
 		},
 	},
+	"read.truncation": {
+		type: "enum",
+		values: ["head", "last", "both"] as const,
+		default: "last",
+		ui: {
+			tab: "editing",
+			label: "Read Truncation",
+			description:
+				"Configured default direction for routes that support directional truncation; bare local and archive reads use this value (factory default: last), while explicit truncation always wins",
+			options: [
+				{ value: "head", label: "Head", description: "Keep the first N lines" },
+				{ value: "last", label: "Last", description: "Keep the last N lines (default)" },
+				{ value: "both", label: "Both", description: "Keep the start and the end, elide the middle" },
+			],
+		},
+	},
 	"read.summaryMaxBytes": {
 		type: "number",
 		default: 20,
@@ -2477,9 +2524,9 @@ export const SETTINGS_SCHEMA = {
 		default: false,
 		ui: {
 			tab: "tools",
-			label: "Insane Search Fallback",
+			label: "Insane Search Fallback (Compatibility)",
 			description:
-				"Opt in to the vendored insane-search escalation for blocked public URL reads (403/WAF/JS-gated). Off by default. Requires preinstalled python3 + curl_cffi (and node + playwright/stealth for the browser phase); changes network posture by enabling TLS/browser impersonation for public pages.",
+				"Compatibility-only preference. Remote renderer fallback stays disabled because it cannot preserve validated per-hop network routing.",
 		},
 	},
 
@@ -2660,6 +2707,47 @@ export const SETTINGS_SCHEMA = {
 			description: "How often the resource GC sweeps browser tabs and stale screenshot directories.",
 		},
 	},
+	"memoryGuard.enabled": {
+		type: "boolean",
+		default: false,
+	},
+	"memoryGuard.checkIntervalMs": {
+		type: "number",
+		default: 30_000,
+		validate: (value: number) => Number.isFinite(value) && value > 0,
+	},
+	"memoryGuard.gcThresholdPercent": {
+		type: "number",
+		default: 70,
+		validate: (value: number) => Number.isFinite(value) && value >= 0 && value <= 100,
+	},
+	"memoryGuard.restartThresholdPercent": {
+		type: "number",
+		default: 85,
+		validate: (value: number) => Number.isFinite(value) && value >= 0 && value <= 100,
+	},
+	"memoryGuard.restartThresholdWindowMs": {
+		type: "number",
+		default: 90_000,
+		validate: (value: number) => Number.isFinite(value) && value > 0,
+	},
+	"memoryGuard.cooldownMs": {
+		type: "number",
+		default: 600_000,
+		validate: (value: number) => Number.isFinite(value) && value >= 0,
+	},
+	"memoryGuard.parentReserveMb": {
+		type: "number",
+		default: 1024,
+		validate: (value: number) =>
+			Number.isFinite(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER / (1024 * 1024),
+	},
+	"memoryGuard.policyLimitMb": {
+		type: "number",
+		default: 0,
+		validate: (value: number) =>
+			Number.isFinite(value) && value >= 0 && value <= Number.MAX_SAFE_INTEGER / (1024 * 1024),
+	},
 
 	"computer.enabled": {
 		type: "boolean",
@@ -3316,25 +3404,71 @@ export const SETTINGS_SCHEMA = {
 	},
 	"providers.image": {
 		type: "enum",
-		values: ["auto", "openai", "gemini", "openrouter", "antigravity"] as const,
+		values: ["auto", "openai", "gemini", "openrouter", "antigravity", "alibaba", "custom"] as const,
 		default: "auto",
 		ui: {
 			tab: "providers",
-			label: "Image Provider",
-			description: "Provider for image generation tool",
+			label: "Image Generation",
+			description: "Provider and model for image generation tool",
 			options: [
 				{
 					value: "auto",
 					label: "Auto",
-					description: "Priority: GPT model image tool > Antigravity > OpenRouter > Gemini",
+					description: "Priority: GPT model image tool > Antigravity > OpenRouter > Gemini > Alibaba",
 				},
-				{ value: "openai", label: "OpenAI", description: "Uses the active GPT Responses/Codex model" },
+				{ value: "openai", label: "OpenAI", description: "Uses gpt-image-2 via OpenAI Responses/Codex" },
 				{ value: "gemini", label: "Gemini", description: "Requires GEMINI_API_KEY" },
 				{ value: "openrouter", label: "OpenRouter", description: "Requires OPENROUTER_API_KEY" },
 				{ value: "antigravity", label: "Antigravity", description: "Requires login with google-antigravity" },
+				{
+					value: "alibaba",
+					label: "Alibaba Bailian",
+					description: "Requires ALIBABA_TOKEN_PLAN_API_KEY (wan2.7-image via Token Plan)",
+				},
+				{
+					value: "custom",
+					label: "Custom",
+					description: "OpenAI-compatible endpoint (set providers.imageCustomUrl)",
+				},
 			],
 		},
 	},
+	"providers.imageModel": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "providers",
+			label: "Image Model",
+			description: "Override the default image generation model for the selected provider",
+		},
+	},
+	"providers.imageCustomUrl": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "providers",
+			label: "Image Custom URL",
+			description: "Base URL for custom OpenAI-compatible image endpoint",
+		},
+	},
+	"providers.imageCustomKey": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "providers",
+			label: "Image Custom API Key",
+			description: "API key for custom OpenAI-compatible image endpoint",
+		},
+	},
+	"providers.imageCustomKeyEnv": {
+		type: "string",
+		default: undefined,
+		ui: {
+			tab: "providers",
+			label: "Image Custom API Key Env",
+			description: "Environment variable name holding the API key for custom image endpoint",
+		},
+	},
 
 	"providers.kimiApiFormat": {
 		type: "enum",
@@ -3943,6 +4077,7 @@ export interface StatusLineSettings {
 	maxRows: number;
 	showHookStatus: boolean;
 	showSkillHud: boolean;
+	showActionHints: boolean;
 	leftSegments: StatusLineSegmentId[];
 	rightSegments: StatusLineSegmentId[];
 	segmentOptions: Record<string, unknown>;
@@ -3981,6 +4116,17 @@ export interface ShellMinimizerSettings {
 	maxCaptureBytes: number;
 }
 
+export interface MemoryGuardSettings {
+	enabled: boolean;
+	checkIntervalMs: number;
+	gcThresholdPercent: number;
+	restartThresholdPercent: number;
+	restartThresholdWindowMs: number;
+	cooldownMs: number;
+	parentReserveMb: number;
+	policyLimitMb: number;
+}
+
 export interface NotificationsSettings {
 	enabled: boolean;
 	telegram: {
@@ -4068,6 +4214,7 @@ export interface GroupTypeMap {
 	statusLine: StatusLineSettings;
 	thinkingBudgets: ThinkingBudgetsSettings;
 	stt: SttSettings;
+	memoryGuard: MemoryGuardSettings;
 	modelRoles: Record<string, ModelSelectorValue>;
 	modelTags: ModelTagsSettings;
 	cycleOrder: string[];