codeep 2.0.4 → 2.1.1

package/README.md

@@ -56,6 +56,7 @@ custom slash commands, lifecycle hooks, checkpoints, `/cost`,
 - **MiniMax** — MiniMax M2.7, M2.5, M2.1, M2 — Coding Plan & pay-per-use API (international & China)
 - **Ollama** — Run any model locally or on a remote server, no API key required. Models are fetched dynamically from your Ollama instance.
 - **OpenRouter** — One key, 100+ models from Anthropic, OpenAI, Google, Meta, Mistral, DeepSeek, Qwen, xAI and more. Per-call cost reported directly by OpenRouter (matches their dashboard exactly). Use `openrouter/auto` to let OpenRouter pick the best model. Tune routing with `/openrouter prefer|ignore|fallbacks|privacy`.
+- **Custom (OpenAI-compatible)** — Point Codeep at any self-hosted or proxied OpenAI-compatible endpoint (vLLM, LiteLLM, LM Studio, text-generation-webui). Set the base URL in `/settings` → **Custom Base URL** (config key `customBaseUrl`, e.g. `http://host:8000/v1`), then pick your model with `/model` (fetched from the server's `/models`). No API key required unless your endpoint enforces one. The `openai` provider also honors the `OPENAI_BASE_URL` env var for proxies that serve `gpt-*` model names.
 - Switch between providers with `/provider`
 - Configure different API keys per provider
 - Both OpenAI-compatible and Anthropic API protocols supported
@@ -73,7 +74,9 @@ When started in a project directory, Codeep automatically:
 - **Session picker** - Choose which session to continue on startup
 - **Per-project sessions** - Sessions stored in `.codeep/sessions/`
 - **Rename sessions** - Give meaningful names with `/rename`
-- **Search history** - Find past conversations with `/search`
+- **AI session titles** - Sessions auto-title themselves with an LLM one-liner ("OAuth2 migration for auth module") instead of a truncated first message. This makes one small background API call per session; turn it off with the `autoSessionTitle` setting (`/settings`) if you prefer zero unsolicited calls
+- **Search current session** - Find text in the open conversation with `/search`
+- **Cross-session recall** - `/recall <query>` searches across **all** saved sessions, ranked by relevance + recency. Add `--resume` to load the top match, or `--summarize` for an LLM recap of what you accomplished across matches
 - **Export** - Save to Markdown, JSON, or plain text
 - `/cost` - Per-session token usage and estimated cost (per provider/model)
 - `/compact [keepN]` - AI-summarize older messages to free up context (keeps last N, default 4)
@@ -709,6 +712,7 @@ codeep account   # Opens browser → sign in with GitHub → CLI is linked
 - **Project archiving** — hide projects from the list with one click
 - **Tasks** — create/complete bug, feature, and task items from the web or directly from the CLI with `/tasks add` and `/tasks done`
 - **API key sync** — store provider keys securely on codeep.dev, sync to any machine in one command
+- **Personal config sync** — personalities and custom slash commands sync across machines; view and prune them on the dashboard
 - **Connected devices** — see all machines linked to your account (hostname, last seen), revoke access per device
 
 ### API key sync
@@ -716,12 +720,32 @@ codeep account   # Opens browser → sign in with GitHub → CLI is linked
 Add keys once on the dashboard, then sync them to any machine:
 
 ```bash
-codeep account sync   # Pull keys from codeep.dev → local config
-codeep account push   # Push local keys → codeep.dev
+codeep account sync   # Pull keys + config from codeep.dev → local
+codeep account push   # Push local keys + config → codeep.dev
 ```
 
 Keys are encrypted at rest using AES-256-GCM.
 
+### Personal config sync
+
+`account sync` / `account push` also carry your **personalities** and **custom
+slash commands** between machines — the Markdown files in
+`~/.codeep/personalities/` and `~/.codeep/commands/`:
+
+```bash
+codeep account push   # Upload local personalities + commands to codeep.dev
+codeep account sync   # Download them onto a new machine
+```
+
+Merging is **additive** — `sync` only writes files that don't already exist
+locally, so it never clobbers a personality or command you've edited on this
+machine. View what's synced (and prune stale entries) under **Personalities**
+and **Custom commands** on the [dashboard](https://codeep.dev/dashboard).
+
+Hooks and MCP server configs are deliberately **not** synced: hooks run
+arbitrary shell, and MCP configs often embed tokens, so both stay local to each
+machine.
+
 ### Tasks
 
 Create, view, and complete tasks directly from the CLI — or manage them on the codeep.dev dashboard:
@@ -973,8 +997,8 @@ In `dangerous` mode, configure which tools require confirmation via `/settings`:
 | Command | Description |
 |---------|-------------|
 | `codeep account` | Link CLI to codeep.dev (GitHub OAuth) |
-| `codeep account sync` | Pull API keys from codeep.dev → local config |
-| `codeep account push` | Push local API keys → codeep.dev |
+| `codeep account sync` | Pull API keys + personalities + commands from codeep.dev → local |
+| `codeep account push` | Push local API keys + personalities + commands → codeep.dev |
 
 ### Authentication
 

package/dist/acp/commands.js

@@ -600,6 +600,29 @@ Anything else the agent should know — edge cases, gotchas, things to double-ch
             }
         }
         // ─── Export ────────────────────────────────────────────────────────────────
+        // ─── Cross-session recall (2.1.0) ─────────────────────────────────────────
+        case 'recall': {
+            const wantSummarize = args.includes('--summarize');
+            // --resume is TUI-only (ACP can't swap the client's conversation
+            // in place); ignore the flag here and just show results.
+            const query = args.filter(a => a !== '--resume' && a !== '--summarize').join(' ');
+            if (!query) {
+                return { handled: true, response: 'Usage: `/recall <query> [--summarize]` — searches across all saved sessions (vs `/search`, current-session only).' };
+            }
+            const { recallSessions, formatRecall, summarizeRecall } = await import('../utils/recall.js');
+            const matches = recallSessions(query, session.workspaceRoot);
+            const header = formatRecall(query, matches);
+            if (wantSummarize && matches.length > 0) {
+                onChunk('_Summarizing matching sessions…_\n\n');
+                const summary = await summarizeRecall(query, matches, session.workspaceRoot);
+                return {
+                    handled: true,
+                    response: summary ? `${header}\n\n---\n\n### Summary\n\n${summary}` : header,
+                    streaming: true,
+                };
+            }
+            return { handled: true, response: header };
+        }
         // ─── Personalities + insights (2.0.3) ─────────────────────────────────────
         case 'personality': {
             const { formatPersonalityList, findPersonality } = await import('../utils/personalities.js');

package/dist/acp/server.js

@@ -35,6 +35,7 @@ const AVAILABLE_COMMANDS = [
     // Sessions
     { name: 'session', description: 'List sessions, or: new / load <name>', input: { hint: 'new | load <name>' } },
     { name: 'save', description: 'Save current session', input: { hint: '[name]' } },
+    { name: 'recall', description: 'Search across ALL saved sessions (cross-session)', input: { hint: '<query> [--summarize]' } },
     // Context
     { name: 'add', description: 'Add files to agent context', input: { hint: '<file> [file2…]' } },
     { name: 'drop', description: 'Remove files from context (no args = clear all)', input: { hint: '[file…]' } },

package/dist/api/index.js

@@ -1,6 +1,6 @@
 import * as http from 'node:http';
 import * as https from 'node:https';
-import { config, getApiKey } from '../config/index.js';
+import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { withRetry, isNetworkError } from '../utils/retry.js';
 import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
@@ -233,15 +233,42 @@ const LANGUAGE_NAMES = {
     'ru': 'Russian (Русский)',
     'hr': 'Croatian (Hrvatski)',
 };
+/**
+ * Build the agent's identity sentence from the active provider + model.
+ * Codeep is the product; the model underneath varies. Stating it
+ * explicitly stops models from guessing their own identity (GLM and
+ * others often claim to be Claude because their training data includes
+ * Claude transcripts).
+ */
+function buildIdentityLine() {
+    const model = String(config.get('model') || '');
+    const providerId = String(config.get('provider') || '');
+    const known = {
+        'z.ai': 'Z.AI', 'z.ai-api': 'Z.AI', 'z.ai-cn': 'Z.AI', 'z.ai-cn-api': 'Z.AI',
+        openai: 'OpenAI', anthropic: 'Anthropic', deepseek: 'DeepSeek', google: 'Google',
+        minimax: 'MiniMax', 'minimax-api': 'MiniMax', 'minimax-cn': 'MiniMax',
+        openrouter: 'OpenRouter', ollama: 'Ollama (local)',
+    };
+    const providerName = known[providerId] || providerId || 'your configured provider';
+    if (model) {
+        return `You are Codeep, an AI coding assistant. You are running on the \`${model}\` model via ${providerName}. If asked which model or provider you are, answer truthfully with these details — do not claim to be a different model.`;
+    }
+    return `You are Codeep, an AI coding assistant.`;
+}
 function getSystemPrompt() {
     const language = config.get('language');
+    // Identity line so the model doesn't hallucinate its name when asked
+    // "what model are you" — without it, models guess from their training
+    // data (e.g. GLM claiming to be Claude). State the truth: the product
+    // is Codeep, the underlying model + provider come from config.
+    const identity = buildIdentityLine();
     let basePrompt;
     if (language === 'auto') {
-        basePrompt = `You are a helpful AI coding assistant. Always respond in the same language as the user's message. Detect the language of the user's input and reply in that same language.`;
+        basePrompt = `${identity} Always respond in the same language as the user's message. Detect the language of the user's input and reply in that same language.`;
     }
     else {
         const langName = LANGUAGE_NAMES[language] || 'English';
-        basePrompt = `You are a helpful AI coding assistant. Always respond in ${langName}, regardless of what language the user writes in.`;
+        basePrompt = `${identity} Always respond in ${langName}, regardless of what language the user writes in.`;
     }
     // Important: This is CHAT mode, not agent mode
     // The model should NOT pretend to execute tools or create files
@@ -309,14 +336,11 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
     const timeout = config.get('apiTimeout');
     const temperature = config.get('temperature');
     const maxTokens = config.get('maxTokens');
-    // Get provider-specific URL and auth
+    // Get provider-specific URL and auth. resolveBaseUrl applies user
+    // overrides: Ollama (ollamaUrl), Custom (customBaseUrl), and OpenAI
+    // (OPENAI_BASE_URL env) — so self-hosted / OpenAI-compatible endpoints work.
     const providerId = config.get('provider');
-    let baseUrl = getProviderBaseUrl(providerId, 'openai');
-    // For Ollama, use the configured URL (can't use lazy require in ESM providers.ts)
-    if (providerId === 'ollama') {
-        const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/$/, '');
-        baseUrl = `${ollamaUrl}/v1`;
-    }
+    let baseUrl = resolveBaseUrl(providerId, 'openai');
     const authHeader = getProviderAuthHeader(providerId, 'openai');
     const useCompletionTokens = usesMaxCompletionTokens(providerId);
     const omitTemperature = requiresDefaultTemperature(providerId);
@@ -720,11 +744,7 @@ export async function validateApiKey(apiKey, providerId) {
     }
     // Determine which protocol to use for validation
     const protocol = providerConfig.defaultProtocol;
-    let baseUrl = getProviderBaseUrl(provider, protocol);
-    if (provider === 'ollama' && protocol === 'openai') {
-        const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/$/, '');
-        baseUrl = `${ollamaUrl}/v1`;
-    }
+    const baseUrl = resolveBaseUrl(provider, protocol);
     const authHeader = getProviderAuthHeader(provider, protocol);
     const model = providerConfig.defaultModel;
     if (!baseUrl) {

package/dist/config/index.d.ts

@@ -23,6 +23,10 @@ interface ConfigSchema {
     plan: 'lite' | 'pro' | 'max';
     language: LanguageCode;
     autoSave: boolean;
+    /** Auto-generate an LLM one-liner title for sessions on save. Makes a
+     *  small background API call (uses the active model) once per session.
+     *  Default true; set false to avoid any unsolicited API calls. */
+    autoSessionTitle: boolean;
     currentSessionId: string;
     temperature: number;
     maxTokens: number;
@@ -31,6 +35,7 @@ interface ConfigSchema {
     rateLimitCommands: number;
     agentMode: AgentMode;
     ollamaUrl: string;
+    customBaseUrl: string;
     agentConfirmation: 'always' | 'dangerous' | 'never';
     agentConfirmDeleteFile: boolean;
     agentConfirmExecuteCommand: boolean;
@@ -130,12 +135,38 @@ export declare function fetchOllamaModels(baseUrl?: string): Promise<{
     name: string;
     description: string;
 }[] | null>;
+/**
+ * Fetch the model list from an OpenAI-compatible server's `/models`
+ * endpoint (vLLM, LiteLLM, LM Studio, etc.). `baseUrl` is the full base
+ * (e.g. http://host:8000/v1). Returns null on error.
+ */
+export declare function fetchOpenAiCompatibleModels(baseUrl: string, apiKey?: string): Promise<{
+    id: string;
+    name: string;
+    description: string;
+}[] | null>;
+/**
+ * Resolve the effective OpenAI-protocol base URL for a provider, honoring
+ * user overrides the static provider table can't express:
+ *   - ollama  → configured `ollamaUrl` + /v1
+ *   - custom  → configured `customBaseUrl` (full base, e.g. http://host:8000/v1)
+ *   - openai  → the OPENAI_BASE_URL env var, if set (OpenAI-SDK convention)
+ * Falls back to the provider's hardcoded base URL. Only the `openai`
+ * protocol takes overrides; the anthropic protocol uses the static table.
+ */
+export declare function resolveBaseUrl(providerId: string, protocol: 'openai' | 'anthropic'): string | null;
 export { PROVIDERS } from './providers';
 export declare function getCurrentSessionId(): string;
 export declare function startNewSession(): string;
 export declare function autoSaveSession(history: Message[], projectPath?: string): boolean;
 export declare function flushAutoSave(): boolean;
 export declare function saveSession(name: string, history: Message[], projectPath?: string): boolean;
+/**
+ * Generate and persist an AI title for a session, if it doesn't have
+ * one yet. Safe to call repeatedly — early-returns when aiTitle exists
+ * or a generation is already in flight.
+ */
+export declare function maybeGenerateSessionTitle(name: string, projectPath?: string): Promise<void>;
 export declare function loadSession(name: string, projectPath?: string): Message[] | null;
 export declare function listSessions(projectPath?: string): string[];
 export declare function deleteSession(name: string, projectPath?: string): boolean;

package/dist/config/index.js

@@ -2,7 +2,7 @@ import Conf from 'conf';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs';
 import { join, dirname } from 'path';
 import { randomUUID } from 'crypto';
-import { PROVIDERS, getProvider } from './providers.js';
+import { PROVIDERS, getProvider, getProviderBaseUrl } from './providers.js';
 import { logSession } from '../utils/logger.js';
 // We'll initialize GLOBAL_SESSIONS_DIR after config is created (to use config.path)
 /**
@@ -144,6 +144,7 @@ function createConfig() {
         model: 'glm-5.1',
         agentMode: 'on',
         ollamaUrl: 'http://localhost:11434',
+        customBaseUrl: '',
         agentConfirmation: 'dangerous',
         agentConfirmDeleteFile: true,
         agentConfirmExecuteCommand: true,
@@ -165,6 +166,7 @@ function createConfig() {
         plan: 'lite',
         language: 'en',
         autoSave: true,
+        autoSessionTitle: true,
         currentSessionId: '',
         temperature: 0.7,
         maxTokens: 32768,
@@ -530,6 +532,59 @@ export async function fetchOllamaModels(baseUrl) {
         return null;
     }
 }
+/**
+ * Fetch the model list from an OpenAI-compatible server's `/models`
+ * endpoint (vLLM, LiteLLM, LM Studio, etc.). `baseUrl` is the full base
+ * (e.g. http://host:8000/v1). Returns null on error.
+ */
+export async function fetchOpenAiCompatibleModels(baseUrl, apiKey) {
+    const base = (baseUrl || '').trim().replace(/\/+$/, '');
+    if (!base)
+        return null;
+    try {
+        const headers = {};
+        if (apiKey)
+            headers['Authorization'] = `Bearer ${apiKey}`;
+        const res = await fetch(`${base}/models`, { headers, signal: AbortSignal.timeout(5000) });
+        if (!res.ok)
+            return null;
+        const data = await res.json();
+        if (!Array.isArray(data.data))
+            return null;
+        return data.data.map(m => ({ id: m.id, name: m.id, description: '' }));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Resolve the effective OpenAI-protocol base URL for a provider, honoring
+ * user overrides the static provider table can't express:
+ *   - ollama  → configured `ollamaUrl` + /v1
+ *   - custom  → configured `customBaseUrl` (full base, e.g. http://host:8000/v1)
+ *   - openai  → the OPENAI_BASE_URL env var, if set (OpenAI-SDK convention)
+ * Falls back to the provider's hardcoded base URL. Only the `openai`
+ * protocol takes overrides; the anthropic protocol uses the static table.
+ */
+export function resolveBaseUrl(providerId, protocol) {
+    const fallback = getProviderBaseUrl(providerId, protocol);
+    if (protocol !== 'openai')
+        return fallback;
+    if (providerId === 'ollama') {
+        const u = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/+$/, '');
+        return `${u}/v1`;
+    }
+    if (providerId === 'custom') {
+        const u = (config.get('customBaseUrl') || '').trim().replace(/\/+$/, '');
+        return u || fallback;
+    }
+    if (providerId === 'openai') {
+        const env = (process.env.OPENAI_BASE_URL || '').trim().replace(/\/+$/, '');
+        if (env)
+            return env;
+    }
+    return fallback;
+}
 // Re-export PROVIDERS for convenience
 export { PROVIDERS } from './providers.js';
 // Generate unique session ID
@@ -599,16 +654,36 @@ export function saveSession(name, history, projectPath) {
         const title = firstUserMsg
             ? firstUserMsg.content.replace(/\n/g, ' ').trim().slice(0, 60)
             : name;
+        const sessionsDir = getSessionsDir(projectPath);
+        const filePath = join(sessionsDir, `${name}.json`);
+        // Preserve an existing aiTitle across re-saves so we don't regenerate.
+        let existingAiTitle;
+        if (existsSync(filePath)) {
+            try {
+                const prev = JSON.parse(readFileSync(filePath, 'utf-8'));
+                existingAiTitle = prev.aiTitle;
+            }
+            catch { /* ignore corrupt prior file */ }
+        }
         const session = {
             name,
             title,
+            aiTitle: existingAiTitle,
             history,
             createdAt: new Date().toISOString(),
         };
-        const sessionsDir = getSessionsDir(projectPath);
-        const filePath = join(sessionsDir, `${name}.json`);
         writeFileSync(filePath, JSON.stringify(session, null, 2));
         logSession('save', name, true);
+        // Fire-and-forget: generate an AI title once the session has enough
+        // content. The orchestrator early-returns if one already exists, so
+        // this is a no-op on every save after the first successful generation.
+        // Gated by autoSessionTitle so privacy/cost-conscious users can opt out
+        // of the (small, background) API call entirely.
+        if (config.get('autoSessionTitle') !== false
+            && !existingAiTitle
+            && history.filter(m => m.role !== 'system').length >= 3) {
+            void maybeGenerateSessionTitle(name, projectPath).catch(() => { });
+        }
         return true;
     }
     catch (error) {
@@ -616,6 +691,49 @@ export function saveSession(name, history, projectPath) {
         return false;
     }
 }
+// Guard against concurrent title generation for the same session during
+// the 5s autosave cadence — only one in-flight call per session name.
+const titlesInFlight = new Set();
+/**
+ * Generate and persist an AI title for a session, if it doesn't have
+ * one yet. Safe to call repeatedly — early-returns when aiTitle exists
+ * or a generation is already in flight.
+ */
+export async function maybeGenerateSessionTitle(name, projectPath) {
+    if (titlesInFlight.has(name))
+        return;
+    const sessionsDir = getSessionsDir(projectPath);
+    const filePath = join(sessionsDir, `${name}.json`);
+    if (!existsSync(filePath))
+        return;
+    let data;
+    try {
+        data = JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return;
+    }
+    if (data.aiTitle)
+        return;
+    titlesInFlight.add(name);
+    try {
+        const { generateSessionTitle } = await import('../utils/sessionTitles.js');
+        const aiTitle = await generateSessionTitle(data.history);
+        if (aiTitle) {
+            // Re-read in case the session was re-saved while we were generating,
+            // so we don't clobber newer history with our stale copy.
+            try {
+                const fresh = JSON.parse(readFileSync(filePath, 'utf-8'));
+                fresh.aiTitle = aiTitle;
+                writeFileSync(filePath, JSON.stringify(fresh, null, 2));
+            }
+            catch { /* ignore */ }
+        }
+    }
+    finally {
+        titlesInFlight.delete(name);
+    }
+}
 export function loadSession(name, projectPath) {
     try {
         const sessionsDir = getSessionsDir(projectPath);
@@ -722,9 +840,12 @@ export function listSessionsWithInfo(projectPath) {
                 const stat = statSync(filePath);
                 const data = JSON.parse(readFileSync(filePath, 'utf-8'));
                 const sessionName = data.name || file.replace('.json', '');
-                // Derive title: use stored title, else first user message, else session name
+                // Title priority: AI-generated one-liner > stored title > first
+                // user message > session name. aiTitle reads far better in
+                // /sessions + /recall ("OAuth2 migration" vs "help me with the…").
                 const firstUserMsg = data.history?.find(m => m.role === 'user');
-                const title = data.title
+                const title = data.aiTitle
+                    || data.title
                     || (firstUserMsg ? firstUserMsg.content.replace(/\n/g, ' ').trim().slice(0, 60) : null)
                     || sessionName;
                 sessions.push({

package/dist/config/providers.js

@@ -331,6 +331,24 @@ export const PROVIDERS = {
         groupLabel: 'Ollama (local)',
         hint: 'Runs locally — no API key or account needed.',
     },
+    'custom': {
+        name: 'Custom (OpenAI-compatible)',
+        description: 'Any OpenAI-compatible endpoint — vLLM, LiteLLM, LM Studio',
+        protocols: {
+            openai: {
+                baseUrl: 'http://localhost:8000/v1',
+                authHeader: 'Bearer',
+                supportsNativeTools: true,
+            },
+        },
+        models: [],
+        defaultModel: '',
+        defaultProtocol: 'openai',
+        noApiKey: true, // key optional — sent as Bearer only if you set one
+        dynamicModels: true,
+        groupLabel: 'Custom',
+        hint: 'Point at any OpenAI-compatible server. Set the URL in /settings (Custom Base URL) or the OPENAI_BASE_URL env var, then pick your model with /model.',
+    },
 };
 export function getProvider(id) {
     return PROVIDERS[id] || null;
@@ -354,6 +372,7 @@ const DISPLAY_ORDER = [
     'minimax',
     'minimax-api',
     'ollama',
+    'custom',
     'z.ai-cn',
     'z.ai-cn-api',
     'minimax-cn',

package/dist/renderer/App.js

@@ -95,6 +95,7 @@ const COMMAND_DESCRIPTIONS = {
     'go': 'Execute the pending plan from /plan',
     'personality': 'Switch agent tone: concise / verbose / security / senior-reviewer / etc',
     'insights': 'Activity summary over the last N days (default 7): runs, files, tools, projects',
+    'recall': 'Search across ALL saved sessions (cross-session; /search is current-session only)',
 };
 import { helpCategories, keyboardShortcuts } from './components/Help.js';
 import { handleSettingsKey, SETTINGS } from './components/Settings.js';
@@ -238,6 +239,8 @@ export class App {
         'plan', 'go',
         // 2.0.3 — personalities + insights.
         'personality', 'insights',
+        // 2.1.0 — cross-session recall.
+        'recall',
         'c', 't', 'd', 'r', 'f', 'e', 'o', 'b', 'p',
     ];
     constructor(options) {

package/dist/renderer/commands.js

@@ -120,6 +120,23 @@ export async function handleCommand(command, args, ctx) {
                     });
                     break;
                 }
+                if (providerId === 'custom') {
+                    const base = config.get('customBaseUrl') || 'http://localhost:8000/v1';
+                    ctx.app.notify(`Fetching models from ${base}…`);
+                    const { fetchOpenAiCompatibleModels, getApiKey: _getKey } = await import('../config/index.js');
+                    const models = await fetchOpenAiCompatibleModels(base, _getKey('custom') || undefined);
+                    if (!models || models.length === 0) {
+                        ctx.app.notify(`Could not list models from ${base}. Set the base URL in /settings, or set the model directly (config key "model").`);
+                        break;
+                    }
+                    const modelItems = models.map(m => ({ key: m.id, label: m.name, description: '' }));
+                    const currentModel = config.get('model');
+                    ctx.app.showSelect(`Select Model (${models.length})`, modelItems, currentModel, (item) => {
+                        config.set('model', item.key);
+                        ctx.app.notify(`Model: ${item.key}`);
+                    });
+                    break;
+                }
                 const { fetchOllamaModels } = await import('../config/index.js');
                 ctx.app.notify('Fetching models from Ollama...');
                 const ollamaModels = await fetchOllamaModels();
@@ -369,13 +386,21 @@ export async function handleCommand(command, args, ctx) {
                 ctx.app.notify('No saved sessions');
                 return;
             }
-            ctx.app.showList('Load Session', sessions.map(s => s.name), (index) => {
+            // Show the readable title (AI-generated > stored > first-message >
+            // name) with a short date for disambiguation, instead of the raw
+            // session id. Loading still keys off the index → session mapping.
+            const labels = sessions.map(s => {
+                const date = new Date(s.createdAt).toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+                const title = s.title && s.title !== s.name ? s.title : s.name;
+                return `${title}  ·  ${date} · ${s.messageCount} msg`;
+            });
+            ctx.app.showList('Load Session', labels, (index) => {
                 const selected = sessions[index];
                 const loaded = loadSession(selected.name, ctx.projectPath);
                 if (loaded) {
                     ctx.app.setMessages(loaded);
                     ctx.setSessionId(selected.name);
-                    ctx.app.notify(`Loaded: ${selected.name}`);
+                    ctx.app.notify(`Loaded: ${selected.title || selected.name}`);
                 }
                 else {
                     ctx.app.notify('Failed to load session');
@@ -589,6 +614,49 @@ Format: use headers per category, only include categories where you found issues
             }
             break;
         }
+        case 'recall': {
+            // Cross-session search (vs /search which is current-session only).
+            // Flags: --resume (load top match), --summarize (LLM recap).
+            const wantResume = args.includes('--resume');
+            const wantSummarize = args.includes('--summarize');
+            const query = args.filter(a => a !== '--resume' && a !== '--summarize').join(' ');
+            if (!query) {
+                ctx.app.notify('Usage: /recall <query> [--resume | --summarize]');
+                return;
+            }
+            const { recallSessions, formatRecall, summarizeRecall } = await import('../utils/recall.js');
+            const matches = recallSessions(query, ctx.projectPath);
+            if (matches.length === 0) {
+                ctx.app.addMessage({ role: 'system', content: formatRecall(query, matches) });
+                break;
+            }
+            if (wantResume) {
+                // Load the top match directly — skip the list + /sessions dance.
+                const top = matches[0];
+                const loaded = loadSession(top.session.name, ctx.projectPath);
+                if (loaded) {
+                    ctx.app.setMessages(loaded);
+                    ctx.setSessionId(top.session.name);
+                    ctx.app.notify(`Resumed: ${top.session.title} (${top.session.name})`);
+                }
+                else {
+                    ctx.app.notify(`Couldn't load ${top.session.name}.`);
+                }
+                break;
+            }
+            if (wantSummarize) {
+                ctx.app.notify('Summarizing matching sessions…');
+                const summary = await summarizeRecall(query, matches, ctx.projectPath);
+                const header = formatRecall(query, matches);
+                const block = summary
+                    ? `${header}\n\n---\n\n### Summary\n\n${summary}`
+                    : header;
+                ctx.app.addMessage({ role: 'system', content: block });
+                break;
+            }
+            ctx.app.addMessage({ role: 'system', content: formatRecall(query, matches) });
+            break;
+        }
         case 'export': {
             const messages = ctx.app.getMessages();
             if (messages.length === 0) {

package/dist/renderer/components/Help.js

@@ -27,7 +27,10 @@ export const helpCategories = [
             { key: '/sessions', description: 'List and load sessions' },
             { key: '/new', description: 'Start new session' },
             { key: '/rename <name>', description: 'Rename current session' },
-            { key: '/search <term>', description: 'Search chat history' },
+            { key: '/search <term>', description: 'Search the current session' },
+            { key: '/recall <query>', description: 'Search across ALL saved sessions (cross-session)' },
+            { key: '/recall … --resume', description: 'Load the top-matching session directly' },
+            { key: '/recall … --summarize', description: 'LLM recap of what you did across matches' },
             { key: '/export [md|json|txt]', description: 'Export chat' },
             { key: '/compact [keepN]', description: 'AI-summarize older messages to free up context (keeps last N)' },
         ],

package/dist/renderer/components/Settings.js

@@ -63,6 +63,16 @@ export const SETTINGS = [
             { value: false, label: 'Off' },
         ],
     },
+    {
+        key: 'autoSessionTitle',
+        label: 'Auto Session Titles',
+        getValue: () => config.get('autoSessionTitle'),
+        type: 'select',
+        options: [
+            { value: true, label: 'On (small background API call)' },
+            { value: false, label: 'Off' },
+        ],
+    },
     {
         key: 'agentMode',
         label: 'Agent Mode',
@@ -121,6 +131,12 @@ export const SETTINGS = [
         getValue: () => config.get('ollamaUrl') || 'http://localhost:11434',
         type: 'text',
     },
+    {
+        key: 'customBaseUrl',
+        label: 'Custom Base URL',
+        getValue: () => config.get('customBaseUrl') || '',
+        type: 'text',
+    },
     {
         key: 'agentApiTimeout',
         label: 'Agent API Timeout (ms)',

package/dist/renderer/main.js

@@ -252,6 +252,14 @@ async function showLoginFlow() {
                 else if (event.key === 'enter') {
                     selectedProvider = providers[selectedProviderIndex];
                     setProvider(selectedProvider.id);
+                    // Providers that don't need a key (Ollama, Custom OpenAI-compatible)
+                    // skip the API-key prompt entirely. Configure their endpoint in
+                    // /settings (Ollama URL / Custom Base URL) once inside the app.
+                    if (selectedProvider.noApiKey) {
+                        cleanup();
+                        resolve('ollama'); // non-null sentinel so the caller proceeds
+                        return;
+                    }
                     currentStep = 'apikey';
                     loginScreen = new LoginScreen(screen, input, {
                         providerName: selectedProvider.name,
@@ -378,8 +386,8 @@ Codeep - AI-powered coding assistant TUI
 Usage:
   codeep              Start interactive chat
   codeep account        Link CLI to your codeep.dev dashboard
-  codeep account sync   Pull API keys from codeep.dev
-  codeep account push   Push local API keys to codeep.dev
+  codeep account sync   Pull keys + personalities + commands from codeep.dev
+  codeep account push   Push local keys + personalities + commands to codeep.dev
   codeep acp          Start ACP server (for Zed editor integration)
   codeep --version    Show version
   codeep --help       Show this help
@@ -411,14 +419,26 @@ Commands (in chat):
             }
             const count = Object.keys(keys).length;
             if (count === 0) {
-                console.log(' no keys found.\n  Add keys at codeep.dev/dashboard\n');
+                console.log(' no keys found.\n  Add keys at codeep.dev/dashboard');
             }
             else {
                 for (const [provider, key] of Object.entries(keys)) {
                     setApiKey(key, provider);
                 }
-                console.log(` synced ${count} key${count !== 1 ? 's' : ''}.\n`);
+                console.log(` synced ${count} key${count !== 1 ? 's' : ''}.`);
             }
+            // Also pull portable personal config — personalities + custom
+            // commands. Additive merge (never clobbers local files).
+            const { pullPersonalities, pullCommands } = await import('../utils/codeepCloud.js');
+            const pCount = await pullPersonalities();
+            if (typeof pCount === 'number' && pCount > 0) {
+                console.log(`  Pulled ${pCount} personalit${pCount === 1 ? 'y' : 'ies'}.`);
+            }
+            const cCount = await pullCommands();
+            if (typeof cCount === 'number' && cCount > 0) {
+                console.log(`  Pulled ${cCount} custom command${cCount === 1 ? '' : 's'}.`);
+            }
+            console.log('');
             process.exit(0);
         }
         if (sub === 'push') {
@@ -444,7 +464,18 @@ Commands (in chat):
             }
             process.stdout.write(`  Pushing ${count} key${count !== 1 ? 's' : ''} to codeep.dev...`);
             const ok = await pushKeys(keys);
-            console.log(ok ? ' done.\n' : ' failed.\n');
+            console.log(ok ? ' done.' : ' failed.');
+            // Also push portable personal config.
+            const { pushPersonalities, pushCommands } = await import('../utils/codeepCloud.js');
+            const pCount = await pushPersonalities();
+            if (typeof pCount === 'number' && pCount > 0) {
+                console.log(`  Pushed ${pCount} personalit${pCount === 1 ? 'y' : 'ies'}.`);
+            }
+            const cCount = await pushCommands();
+            if (typeof cCount === 'number' && cCount > 0) {
+                console.log(`  Pushed ${cCount} custom command${cCount === 1 ? '' : 's'}.`);
+            }
+            console.log('');
             process.exit(ok ? 0 : 1);
         }
         const { runAccountFlow } = await import('../utils/codeepCloud.js');

package/dist/utils/agentChat.js

@@ -13,10 +13,10 @@
  */
 import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
-import { config, getApiKey } from '../config/index.js';
+import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from './projectIntelligence.js';
 import { syncProgress, generateProjectId } from './codeepCloud.js';
-import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, isNoApiKeyProvider } from '../config/providers.js';
+import { getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens, usesMaxCompletionTokens, requiresDefaultTemperature, isNoApiKeyProvider } from '../config/providers.js';
 import { recordTokenUsage, extractOpenAIUsage, extractAnthropicUsage } from './tokenTracker.js';
 import { parseOpenAIToolCalls, parseAnthropicToolCalls, parseToolCalls } from './toolParsing.js';
 import { formatToolDefinitions, getOpenAITools, getAnthropicTools } from './tools.js';
@@ -182,7 +182,14 @@ export function formatChatHistoryForAgent(history, maxChars = 16000) {
 }
 export function getAgentSystemPrompt(projectContext) {
     const root = projectContext.root || process.cwd();
-    return `You are Codeep, an autonomous AI coding agent operating inside this project. Never refer to yourself as Claude or any other AI.
+    // State the real underlying model/provider so "which model are you"
+    // gets a truthful answer instead of a hallucinated one.
+    const model = String(config.get('model') || '');
+    const providerId = String(config.get('provider') || '');
+    const identity = model
+        ? `You are Codeep, an autonomous AI coding agent operating inside this project. The underlying model is \`${model}\` (via ${providerId}). If asked which model or provider you are, answer truthfully with these details. Never claim to be Claude or any other model unless that is genuinely the configured model.`
+        : `You are Codeep, an autonomous AI coding agent operating inside this project. Never refer to yourself as Claude or any other AI unless that is genuinely the configured model.`;
+    return `${identity}
 
 ## Tools
 - read_file / write_file / edit_file / delete_file — file ops (prefer edit_file for modifications to keep surrounding content intact)
@@ -232,11 +239,7 @@ additionalTools) {
     const model = config.get('model');
     const providerId = config.get('provider');
     const apiKey = getApiKey() || (isNoApiKeyProvider(providerId) ? 'ollama' : null);
-    let baseUrl = getProviderBaseUrl(providerId, protocol);
-    if (providerId === 'ollama' && protocol === 'openai') {
-        const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/$/, '');
-        baseUrl = `${ollamaUrl}/v1`;
-    }
+    let baseUrl = resolveBaseUrl(providerId, protocol);
     const authHeader = getProviderAuthHeader(providerId, protocol);
     if (!baseUrl)
         throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);
@@ -406,11 +409,7 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
     const model = config.get('model');
     const providerId = config.get('provider');
     const apiKey = getApiKey() || (isNoApiKeyProvider(providerId) ? 'ollama' : null);
-    let baseUrl = getProviderBaseUrl(providerId, protocol);
-    if (providerId === 'ollama' && protocol === 'openai') {
-        const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').replace(/\/$/, '');
-        baseUrl = `${ollamaUrl}/v1`;
-    }
+    let baseUrl = resolveBaseUrl(providerId, protocol);
     const authHeader = getProviderAuthHeader(providerId, protocol);
     if (!baseUrl)
         throw new Error(`Provider ${providerId} does not support ${protocol} protocol`);

package/dist/utils/codeepCloud.d.ts

@@ -65,6 +65,10 @@ export declare function pullKeys(): Promise<Record<string, string> | null>;
  * Returns true on success.
  */
 export declare function pushKeys(keys: Record<string, string>): Promise<boolean>;
+export declare const pullPersonalities: () => Promise<number | null>;
+export declare const pushPersonalities: () => Promise<number | null>;
+export declare const pullCommands: () => Promise<number | null>;
+export declare const pushCommands: () => Promise<number | null>;
 /**
  * Sync session conversation history to codeep.dev.
  * Only user/assistant messages are sent — system messages are filtered out.

package/dist/utils/codeepCloud.js

@@ -209,6 +209,102 @@ export async function pushKeys(keys) {
     });
     return res?.ok ?? false;
 }
+// ─── Portable personal config sync (personalities + commands) ──────────────────
+//
+// Both are name → raw-.md-body bundles stored in a global dir
+// (~/.codeep/personalities, ~/.codeep/commands). The sync is bidirectional
+// and merge-based: pull writes any remote file not present locally; push
+// sends every local file. Last-write-wins on the server via upsert. We
+// never delete locally on pull — additive only, so a sync can't nuke
+// work you haven't pushed.
+import { readFileSync, readdirSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+function globalDir(kind) {
+    return join(homedir(), '.codeep', kind);
+}
+/** Read every <name>.md in a global config dir into a { name → body } map. */
+function readFileBundle(kind) {
+    const dir = globalDir(kind);
+    if (!existsSync(dir))
+        return {};
+    const out = {};
+    try {
+        for (const f of readdirSync(dir)) {
+            if (!f.endsWith('.md'))
+                continue;
+            const name = f.slice(0, -3).toLowerCase();
+            if (!/^[a-z0-9][a-z0-9-]*$/.test(name) || name.length > 64)
+                continue;
+            try {
+                const body = readFileSync(join(dir, f), 'utf8');
+                if (body.length <= 64 * 1024)
+                    out[name] = body;
+            }
+            catch { /* skip unreadable */ }
+        }
+    }
+    catch { /* dir read failed */ }
+    return out;
+}
+/** Write a { name → body } map into a global config dir as <name>.md
+ *  files. Only writes files that don't already exist (additive merge —
+ *  never clobber local edits). Returns the count of newly written files. */
+function writeFileBundle(kind, items) {
+    const dir = globalDir(kind);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    let written = 0;
+    for (const [name, body] of Object.entries(items)) {
+        if (!/^[a-z0-9][a-z0-9-]*$/.test(name) || name.length > 64 || typeof body !== 'string' || !body)
+            continue;
+        const filePath = join(dir, `${name}.md`);
+        if (existsSync(filePath))
+            continue; // don't clobber local
+        try {
+            writeFileSync(filePath, body);
+            written++;
+        }
+        catch { /* skip */ }
+    }
+    return written;
+}
+async function pullBundle(kind) {
+    const syncToken = getSyncToken();
+    if (!syncToken)
+        return null;
+    const res = await fetchWithRetry(`${API_BASE}/api/${kind}`, { headers: { 'x-sync-token': syncToken } });
+    if (!res?.ok)
+        return null;
+    try {
+        const data = await res.json();
+        if (!data.ok)
+            return null;
+        return writeFileBundle(kind, data.items ?? {});
+    }
+    catch {
+        return null;
+    }
+}
+async function pushBundle(kind) {
+    const syncToken = getSyncToken();
+    if (!syncToken)
+        return null;
+    const items = readFileBundle(kind);
+    const count = Object.keys(items).length;
+    if (count === 0)
+        return 0;
+    const res = await fetchWithRetry(`${API_BASE}/api/${kind}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', 'x-sync-token': syncToken },
+        body: JSON.stringify({ items }),
+    });
+    return res?.ok ? count : null;
+}
+export const pullPersonalities = () => pullBundle('personalities');
+export const pushPersonalities = () => pushBundle('personalities');
+export const pullCommands = () => pullBundle('commands');
+export const pushCommands = () => pushBundle('commands');
 // ─── Session history sync ─────────────────────────────────────────────────────
 /**
  * Sync session conversation history to codeep.dev.

package/dist/utils/recall.d.ts

@@ -0,0 +1,41 @@
+/**
+ * `/recall` — cross-session search.
+ *
+ * Distinct from `/search`, which scans only the *current* session's
+ * messages. `/recall` scans every saved session in the active scope
+ * (project sessions under `<workspace>/.codeep/sessions/` when in a
+ * project, else global `~/.codeep/sessions/`) and surfaces the ones
+ * that match — ranked by how many query terms hit, boosted by recency.
+ *
+ * No FTS index / SQLite dependency: sessions are JSON files, and for
+ * the realistic case (tens to low-hundreds of sessions) an in-memory
+ * scan is fast and dependency-free. If a power user accumulates
+ * thousands of sessions and this gets slow, the natural upgrade is a
+ * cached FTS5 index — but that's premature today.
+ */
+import { type SessionInfo } from '../config/index.js';
+export interface RecallMatch {
+    session: SessionInfo;
+    /** Composite relevance: term-hit count + recency boost. */
+    score: number;
+    /** Context snippet from the best-matching message. */
+    snippet: string;
+    /** How many messages in the session matched at least one term. */
+    matchedMessages: number;
+}
+/**
+ * Search saved sessions for the query. A session matches only if EVERY
+ * query term appears somewhere in its non-system messages (AND
+ * semantics — narrows results to genuinely relevant sessions rather
+ * than any-term noise). Returns up to `limit` matches, best first.
+ */
+export declare function recallSessions(query: string, projectPath?: string, limit?: number): RecallMatch[];
+/**
+ * LLM-summarize what was accomplished across the matching sessions.
+ * Loads each match's history, builds a compact multi-session transcript,
+ * and asks the model for a short "here's what you did" paragraph. Used
+ * by `/recall <query> --summarize`. Returns null on chat failure.
+ */
+export declare function summarizeRecall(query: string, matches: RecallMatch[], projectPath?: string): Promise<string | null>;
+/** Render recall results as a Markdown block for TUI / ACP display. */
+export declare function formatRecall(query: string, matches: RecallMatch[]): string;

package/dist/utils/recall.js

@@ -0,0 +1,150 @@
+/**
+ * `/recall` — cross-session search.
+ *
+ * Distinct from `/search`, which scans only the *current* session's
+ * messages. `/recall` scans every saved session in the active scope
+ * (project sessions under `<workspace>/.codeep/sessions/` when in a
+ * project, else global `~/.codeep/sessions/`) and surfaces the ones
+ * that match — ranked by how many query terms hit, boosted by recency.
+ *
+ * No FTS index / SQLite dependency: sessions are JSON files, and for
+ * the realistic case (tens to low-hundreds of sessions) an in-memory
+ * scan is fast and dependency-free. If a power user accumulates
+ * thousands of sessions and this gets slow, the natural upgrade is a
+ * cached FTS5 index — but that's premature today.
+ */
+import { listSessionsWithInfo, loadSession } from '../config/index.js';
+/**
+ * Search saved sessions for the query. A session matches only if EVERY
+ * query term appears somewhere in its non-system messages (AND
+ * semantics — narrows results to genuinely relevant sessions rather
+ * than any-term noise). Returns up to `limit` matches, best first.
+ */
+export function recallSessions(query, projectPath, limit = 10) {
+    const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    if (terms.length === 0)
+        return [];
+    const sessions = listSessionsWithInfo(projectPath);
+    const matches = [];
+    for (const session of sessions) {
+        const history = loadSession(session.name, projectPath);
+        if (!history || history.length === 0)
+            continue;
+        let totalTermHits = 0;
+        let matchedMessages = 0;
+        let bestSnippet = '';
+        let bestSnippetTermCount = 0;
+        // Track which terms appear anywhere in the session (for AND gate).
+        const termsSeen = new Set();
+        for (const msg of history) {
+            if (msg.role === 'system')
+                continue;
+            const lower = msg.content.toLowerCase();
+            const termsInMsg = terms.filter((t) => lower.includes(t));
+            if (termsInMsg.length === 0)
+                continue;
+            matchedMessages++;
+            totalTermHits += termsInMsg.length;
+            for (const t of termsInMsg)
+                termsSeen.add(t);
+            // Pick the snippet from whichever message hits the most distinct terms.
+            if (termsInMsg.length > bestSnippetTermCount) {
+                bestSnippetTermCount = termsInMsg.length;
+                bestSnippet = extractSnippet(msg.content, termsInMsg[0]);
+            }
+        }
+        // AND gate: every query term must appear somewhere in the session.
+        if (termsSeen.size < terms.length)
+            continue;
+        // Recency boost: sessions touched in the last ~10 days get up to +10,
+        // tapering linearly. Keeps "what did I do recently" answers near the top
+        // without drowning out an older session that's a much stronger text match.
+        const ageDays = (Date.now() - new Date(session.createdAt).getTime()) / 86_400_000;
+        const recencyBoost = Math.max(0, 10 - ageDays);
+        const score = totalTermHits + recencyBoost;
+        matches.push({ session, score, snippet: bestSnippet, matchedMessages });
+    }
+    return matches.sort((a, b) => b.score - a.score).slice(0, limit);
+}
+/** Extract a one-line context window around the first match of `term`. */
+function extractSnippet(content, term) {
+    const lower = content.toLowerCase();
+    const idx = lower.indexOf(term.toLowerCase());
+    if (idx === -1)
+        return content.slice(0, 120).replace(/\s+/g, ' ').trim();
+    const start = Math.max(0, idx - 40);
+    const end = Math.min(content.length, idx + term.length + 80);
+    const prefix = start > 0 ? '…' : '';
+    const suffix = end < content.length ? '…' : '';
+    return prefix + content.slice(start, end).replace(/\s+/g, ' ').trim() + suffix;
+}
+function relativeAge(iso) {
+    const days = Math.floor((Date.now() - new Date(iso).getTime()) / 86_400_000);
+    if (days === 0)
+        return 'today';
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days}d ago`;
+    if (days < 30)
+        return `${Math.floor(days / 7)}w ago`;
+    return new Date(iso).toISOString().slice(0, 10);
+}
+/**
+ * LLM-summarize what was accomplished across the matching sessions.
+ * Loads each match's history, builds a compact multi-session transcript,
+ * and asks the model for a short "here's what you did" paragraph. Used
+ * by `/recall <query> --summarize`. Returns null on chat failure.
+ */
+export async function summarizeRecall(query, matches, projectPath) {
+    if (matches.length === 0)
+        return null;
+    // Build a transcript across the top matches, capped so the prompt
+    // stays affordable even when many sessions match.
+    const blocks = [];
+    for (const m of matches.slice(0, 5)) {
+        const history = loadSession(m.session.name, projectPath);
+        if (!history)
+            continue;
+        const turns = history
+            .filter((msg) => msg.role !== 'system')
+            .slice(0, 8)
+            .map((msg) => `${msg.role}: ${msg.content.replace(/\s+/g, ' ').slice(0, 300)}`)
+            .join('\n');
+        blocks.push(`### Session: ${m.session.name} (${relativeAge(m.session.createdAt)})\n${turns}`);
+    }
+    if (blocks.length === 0)
+        return null;
+    const system = `You are summarizing a developer's past work sessions that matched the search "${query}". Read the transcripts and write a SHORT recap (2-4 sentences) of what they actually accomplished across these sessions — concrete changes, decisions, and any unfinished threads. Use past tense. No preamble, no bullet headers, just the recap paragraph.`;
+    try {
+        const { chat } = await import('../api/index.js');
+        const summary = await chat(blocks.join('\n\n'), [{ role: 'system', content: system }]);
+        return summary.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Render recall results as a Markdown block for TUI / ACP display. */
+export function formatRecall(query, matches) {
+    if (matches.length === 0) {
+        return `_No saved sessions match "${query}"._\n\nTip: \`/recall\` searches across all your sessions. For the current session only, use \`/search\`.`;
+    }
+    const lines = [
+        `## Recall: "${query}"`,
+        '',
+        `${matches.length} session${matches.length === 1 ? '' : 's'} match${matches.length === 1 ? 'es' : ''}, best first:`,
+        '',
+    ];
+    for (const m of matches) {
+        const age = relativeAge(m.session.createdAt);
+        const title = m.session.title && m.session.title !== m.session.name ? m.session.title : '';
+        lines.push(`**${m.session.name}**${title ? ` — ${title}` : ''}`);
+        lines.push(`_${age} · ${m.session.messageCount} messages · ${m.matchedMessages} matched_`);
+        if (m.snippet)
+            lines.push(`> ${m.snippet}`);
+        lines.push('');
+    }
+    lines.push('Resume one with `/sessions` and pick it from the list.');
+    return lines.join('\n').trim();
+}

package/dist/utils/sessionTitles.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Auto-generated session titles.
+ *
+ * The default title is the first user message truncated to 60 chars —
+ * which makes `/sessions` and `/recall` read like "help me fix the…",
+ * "can you add a…". This module replaces that with an LLM one-liner
+ * ("OAuth2 migration for auth module") generated once per session, in
+ * the background, after the session has enough content to summarize.
+ *
+ * Design notes:
+ *   - Fire-and-forget from saveSession. Never blocks a save.
+ *   - One-shot: once `aiTitle` is written to the session file, the
+ *     generator early-returns. An in-flight guard prevents concurrent
+ *     duplicate calls during the 5s autosave cadence.
+ *   - Uses the user's active model via chat() — a 4-8 word completion
+ *     is negligible cost, and respecting the active model means it
+ *     works for every provider without special-casing.
+ */
+import type { Message } from '../config/index.js';
+/**
+ * Generate a short title from a session's history, or null if there
+ * isn't enough to summarize (fewer than 3 non-system messages) or the
+ * LLM call fails. The caller persists the result.
+ */
+export declare function generateSessionTitle(history: Message[]): Promise<string | null>;

package/dist/utils/sessionTitles.js

@@ -0,0 +1,58 @@
+/**
+ * Auto-generated session titles.
+ *
+ * The default title is the first user message truncated to 60 chars —
+ * which makes `/sessions` and `/recall` read like "help me fix the…",
+ * "can you add a…". This module replaces that with an LLM one-liner
+ * ("OAuth2 migration for auth module") generated once per session, in
+ * the background, after the session has enough content to summarize.
+ *
+ * Design notes:
+ *   - Fire-and-forget from saveSession. Never blocks a save.
+ *   - One-shot: once `aiTitle` is written to the session file, the
+ *     generator early-returns. An in-flight guard prevents concurrent
+ *     duplicate calls during the 5s autosave cadence.
+ *   - Uses the user's active model via chat() — a 4-8 word completion
+ *     is negligible cost, and respecting the active model means it
+ *     works for every provider without special-casing.
+ */
+const TITLE_SYSTEM_PROMPT = `You write concise titles for coding sessions. Given a transcript, reply with ONLY a 4-8 word title that captures the main task. No quotes. No trailing period. No preamble.
+
+Good examples:
+- OAuth2 migration for auth module
+- Fix flaky payment integration tests
+- Add dark mode to settings page
+- Debug WebSocket reconnection loop
+
+Reply with the title and nothing else.`;
+/**
+ * Generate a short title from a session's history, or null if there
+ * isn't enough to summarize (fewer than 3 non-system messages) or the
+ * LLM call fails. The caller persists the result.
+ */
+export async function generateSessionTitle(history) {
+    const turns = history.filter((m) => m.role !== 'system');
+    if (turns.length < 3)
+        return null;
+    // Compact transcript: first 6 turns, each capped, so the prompt stays
+    // cheap regardless of how long the session ran.
+    const transcript = turns
+        .slice(0, 6)
+        .map((m) => `${m.role}: ${m.content.replace(/\s+/g, ' ').slice(0, 400)}`)
+        .join('\n');
+    try {
+        const { chat } = await import('../api/index.js');
+        const raw = await chat(transcript, [{ role: 'system', content: TITLE_SYSTEM_PROMPT }]);
+        const cleaned = raw
+            .replace(/^["'`]+|["'`]+$/g, '') // strip wrapping quotes
+            .replace(/[.\s]+$/, '') // strip trailing period / whitespace
+            .replace(/\s+/g, ' ')
+            .trim();
+        if (!cleaned)
+            return null;
+        return cleaned.length > 70 ? cleaned.slice(0, 67) + '…' : cleaned;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/utils/taskPlanner.js

@@ -1,8 +1,8 @@
 /**
  * Task Planning - breaks down complex tasks into subtasks
  */
-import { config, getApiKey } from '../config/index.js';
-import { getProviderBaseUrl, getProviderAuthHeader, requiresDefaultTemperature } from '../config/providers.js';
+import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
+import { getProviderAuthHeader, requiresDefaultTemperature } from '../config/providers.js';
 /**
  * Ask AI to break down a complex task into subtasks
  */
@@ -43,7 +43,7 @@ Break this down into subtasks. Each task = one file or one logical unit. Respond
         const protocol = config.get('protocol');
         const provider = config.get('provider');
         const model = config.get('model');
-        const baseUrl = getProviderBaseUrl(provider, protocol);
+        const baseUrl = resolveBaseUrl(provider, protocol);
         const authHeaderType = getProviderAuthHeader(provider, protocol);
         const messages = [
             { role: 'user', content: systemPrompt }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.0.4",
+  "version": "2.1.1",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",