codeep 2.3.0 → 2.4.0

package/README.md

@@ -257,7 +257,7 @@ Commands:
 - `/me learn project` — one-off learn scoped to this repo
 - `/me forget` — clear the auto-learned profile(s)
 
-Sync your global profile across machines (and edit it on the web) from the [dashboard](https://codeep.dev/dashboard) with `codeep account sync`. In VS Code: **Codeep: Edit Profile** and **Codeep: Toggle Profile Auto-Learn**.
+Sync your global profile across machines (and edit it on the web) from the [dashboard](https://codeep.dev/dashboard): `/me sync` (or `codeep account sync`, which now carries the profile too). In VS Code: **Codeep: Edit Profile**, **Codeep: Toggle Profile Auto-Learn**, **Codeep: Sync Profile to Dashboard**.
 
 ### Sub-agents (delegation)
 The agent can delegate a self-contained sub-task to a specialist **sub-agent** that runs in its own fresh context window and returns only a summary — keeping the main context small and letting each sub-task run with a tuned persona and scoped tools.
@@ -1016,6 +1016,8 @@ In `dangerous` mode, configure which tools require confirmation via `/settings`:
 | `/memory remove <n>` | Remove note by index |
 | `/memory clear` | Clear all notes |
 | `/model pull <name>` | Pull an Ollama model (local Ollama only) |
+| `/model browse` | Browse a curated catalog of local coding models and pull one (Ollama) |
+| `/model rm <name>` | Remove a locally-installed Ollama model (local only) |
 
 ### Skills
 

package/dist/acp/commands.js

@@ -697,6 +697,22 @@ Anything else the agent should know — edge cases, gotchas, things to double-ch
                         ? 'Cleared the auto-learned profile(s).'
                         : 'No learned profile to clear.' };
             }
+            if (sub === 'sync') {
+                const { getSyncToken } = await import('../config/index.js');
+                if (!getSyncToken())
+                    return { handled: true, response: 'Not linked to codeep.dev. Run `codeep account` in a terminal first.' };
+                const { pushUserProfile, pullUserProfile } = await import('../utils/codeepCloud.js');
+                const pushed = await pushUserProfile();
+                const pulled = await pullUserProfile();
+                const lines = [];
+                if (pushed)
+                    lines.push('✓ Profile pushed to the dashboard');
+                if (pulled === 1)
+                    lines.push('✓ Profile pulled to this machine');
+                if (lines.length === 0)
+                    lines.push('Nothing to sync yet — run `/me init` and fill in your profile first.');
+                return { handled: true, response: lines.join('\n') };
+            }
             return { handled: true, response: formatProfileView(session.workspaceRoot) };
         }
         case 'insights': {

package/dist/acp/server.js

@@ -58,7 +58,7 @@ const AVAILABLE_COMMANDS = [
     { name: 'go', description: 'Execute the pending plan from /plan' },
     // Personalities + insights (2.0.3)
     { name: 'personality', description: 'List or switch agent tone preset', input: { hint: '[name | off]' } },
-    { name: 'me', description: 'Your user profile — adapts the agent to you (reply language, style, stack)', input: { hint: '[init [project] | on | off | learn [on|off|project] | forget]' } },
+    { name: 'me', description: 'Your user profile — adapts the agent to you (reply language, style, stack)', input: { hint: '[init [project] | on | off | learn [on|off|project] | forget | sync]' } },
     { name: 'agents', description: 'List sub-agents the agent can delegate self-contained tasks to' },
     { name: 'insights', description: 'Activity summary over the last N days (default 7)', input: { hint: '[--days N]' } },
     // Project intelligence

package/dist/api/index.js

@@ -394,6 +394,30 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
         ...(openRouterProvider ? { provider: openRouterProvider } : {}),
     });
     try {
+        // Opt-in native Ollama transport (plain chat). When `ollamaNativeApi` is on,
+        // route through /api/chat so num_ctx + keep_alive apply and the real context
+        // window is used. OFF by default → falls through to the /v1 shim below
+        // unchanged. Plain chat sends no tools, so the native call is simple here.
+        if (providerId === 'ollama' && config.get('ollamaNativeApi') === true) {
+            const { streamOllamaNativeChat, getOllamaContextLength } = await import('./ollamaNative.js');
+            const ollamaUrl = config.get('ollamaUrl') || 'http://localhost:11434';
+            const cfgCtx = Number(config.get('ollamaNumCtx')) || 0;
+            const numCtx = cfgCtx > 0 ? cfgCtx : ((await getOllamaContextLength(model, ollamaUrl)) ?? undefined);
+            const result = await streamOllamaNativeChat({
+                baseUrl: ollamaUrl,
+                model,
+                messages,
+                numCtx,
+                keepAlive: config.get('ollamaKeepAlive') || undefined,
+                temperature: omitTemperature ? undefined : temperature,
+                timeoutMs: timeout,
+                onChunk: stream ? onChunk : undefined,
+            });
+            if (result.promptTokens != null && result.completionTokens != null) {
+                recordTokenUsage({ promptTokens: result.promptTokens, completionTokens: result.completionTokens, totalTokens: result.promptTokens + result.completionTokens }, model, providerId);
+            }
+            return stripThinkTags(result.text);
+        }
         // Use node:http for Ollama — bypasses undici connection pooling (AggregateError in Node v24)
         if (providerId === 'ollama') {
             const nodeStream = await httpRequest(`${baseUrl}/chat/completions`, {

package/dist/api/ollamaNative.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Native Ollama `/api/chat` transport.
+ *
+ * Why this exists: Codeep normally talks to Ollama through its OpenAI-compatible
+ * `/v1/chat/completions` shim, which silently IGNORES Ollama-native options like
+ * `num_ctx` (context window) and `keep_alive` (model residency). The shim also
+ * defaults to a small context (~2-4k) regardless of the model's real window, so
+ * long sessions get silently truncated server-side.
+ *
+ * The native `/api/chat` endpoint accepts those options and streams
+ * newline-delimited JSON (NOT SSE). Each line is a full JSON object:
+ *   {"message":{"role":"assistant","content":"…"},"done":false}
+ *   …
+ *   {"message":{"content":""},"done":true,"prompt_eval_count":N,"eval_count":M}
+ *
+ * This module keeps the line-parsing as PURE functions so they can be unit
+ * tested without a live server. The networking wrapper lives at the bottom.
+ */
+/** A tool call as Ollama's native /api/chat returns it: `function.arguments`
+ *  is a JSON OBJECT (unlike OpenAI's JSON-string form). */
+export interface OllamaToolCall {
+    name: string;
+    arguments: Record<string, unknown>;
+}
+export interface OllamaStreamDelta {
+    /** Text chunk from this line (may be empty). */
+    content: string;
+    /** True on the terminating line. */
+    done: boolean;
+    /** Tool calls present on this line (Ollama emits them on one message). */
+    toolCalls?: OllamaToolCall[];
+    /** Prompt (input) tokens — only present on the final line. */
+    promptTokens?: number;
+    /** Completion (output) tokens — only present on the final line. */
+    completionTokens?: number;
+}
+/** Extract + normalize `message.tool_calls` from a parsed message. Returns
+ *  undefined when none. Tolerates missing/malformed entries (never throws). */
+export declare function extractOllamaToolCalls(msg: unknown): OllamaToolCall[] | undefined;
+/**
+ * Parse a single newline-delimited JSON line from `/api/chat`. Returns null for
+ * blank lines or unparseable keepalives (never throws). Tolerates both the
+ * streaming shape (`message.content`) and the non-stream shape.
+ */
+export declare function parseOllamaChatLine(line: string): OllamaStreamDelta | null;
+export interface OllamaAccumulator {
+    text: string;
+    toolCalls: OllamaToolCall[];
+    promptTokens?: number;
+    completionTokens?: number;
+    done: boolean;
+}
+/**
+ * Fold a parsed delta into a running accumulator. Pure — no I/O. The caller
+ * feeds each line's parse result here and reads `text` / token counts at the end.
+ */
+export declare function foldOllamaDelta(acc: OllamaAccumulator, delta: OllamaStreamDelta | null): OllamaAccumulator;
+/**
+ * Split a buffer into complete lines + a trailing remainder. Pure helper so the
+ * stream reader can carry partial lines across chunk boundaries correctly.
+ * Returns { lines, rest } where `rest` is the unfinished tail (no newline yet).
+ */
+export declare function splitOllamaLines(buffer: string): {
+    lines: string[];
+    rest: string;
+};
+export declare const initialOllamaAccumulator: () => OllamaAccumulator;
+/**
+ * Pull the real context_length out of an `/api/show` response's `model_info`.
+ * The key is architecture-prefixed (e.g. `llama.context_length`,
+ * `qwen2.context_length`), so we scan for any key ending in `.context_length`
+ * (or the bare `context_length`). Pure + tolerant — returns null when absent.
+ */
+export declare function extractContextLength(showResponse: unknown): number | null;
+/**
+ * Fetch a model's real maximum context window via `/api/show`. Cached per model;
+ * returns null on any error (caller falls back to its default). Never throws.
+ */
+export declare function getOllamaContextLength(model: string, ollamaBaseUrl: string): Promise<number | null>;
+/** Test seam — reset the per-model context cache. */
+export declare function _clearOllamaContextCache(): void;
+export interface OllamaChatOptions {
+    /** Ollama base URL (without /v1), e.g. http://localhost:11434 */
+    baseUrl: string;
+    model: string;
+    /** Messages in OpenAI shape {role, content} — Ollama /api/chat accepts these. */
+    messages: {
+        role: string;
+        content: string;
+    }[];
+    /** num_ctx — the context window to allocate. 0/undefined = let Ollama decide. */
+    numCtx?: number;
+    /** keep_alive — how long to keep the model resident, e.g. "30m". */
+    keepAlive?: string;
+    temperature?: number;
+    timeoutMs?: number;
+    onChunk?: (text: string) => void;
+    /** Tool definitions in OpenAI function format. Ollama's /api/chat accepts the
+     *  same `{type:'function',function:{...}}` shape and returns `tool_calls`. */
+    tools?: unknown[];
+    /** Pass-through for non-string message parts (tool results carry tool_call_id
+     *  etc.). When set, used verbatim instead of `messages`. */
+    rawMessages?: unknown[];
+}
+export interface OllamaChatResult {
+    text: string;
+    toolCalls: OllamaToolCall[];
+    promptTokens?: number;
+    completionTokens?: number;
+}
+/**
+ * Stream a chat completion from Ollama's native `/api/chat`. Uses node:http to
+ * sidestep undici's connection pooling (which throws AggregateError against
+ * localhost Ollama on Node 24). Parses the newline-JSON stream via the pure
+ * helpers above. Resolves with the full text + token usage.
+ */
+export declare function streamOllamaNativeChat(opts: OllamaChatOptions): Promise<OllamaChatResult>;

package/dist/api/ollamaNative.js

@@ -0,0 +1,228 @@
+/**
+ * Native Ollama `/api/chat` transport.
+ *
+ * Why this exists: Codeep normally talks to Ollama through its OpenAI-compatible
+ * `/v1/chat/completions` shim, which silently IGNORES Ollama-native options like
+ * `num_ctx` (context window) and `keep_alive` (model residency). The shim also
+ * defaults to a small context (~2-4k) regardless of the model's real window, so
+ * long sessions get silently truncated server-side.
+ *
+ * The native `/api/chat` endpoint accepts those options and streams
+ * newline-delimited JSON (NOT SSE). Each line is a full JSON object:
+ *   {"message":{"role":"assistant","content":"…"},"done":false}
+ *   …
+ *   {"message":{"content":""},"done":true,"prompt_eval_count":N,"eval_count":M}
+ *
+ * This module keeps the line-parsing as PURE functions so they can be unit
+ * tested without a live server. The networking wrapper lives at the bottom.
+ */
+import http from 'http';
+import https from 'https';
+/** Extract + normalize `message.tool_calls` from a parsed message. Returns
+ *  undefined when none. Tolerates missing/malformed entries (never throws). */
+export function extractOllamaToolCalls(msg) {
+    const raw = msg?.tool_calls;
+    if (!Array.isArray(raw) || raw.length === 0)
+        return undefined;
+    const out = [];
+    for (const tc of raw) {
+        const fn = tc?.function;
+        const name = typeof fn?.name === 'string' ? fn.name : '';
+        if (!name)
+            continue;
+        let args = {};
+        const a = fn?.arguments;
+        if (a && typeof a === 'object')
+            args = a;
+        else if (typeof a === 'string') {
+            try {
+                args = JSON.parse(a);
+            }
+            catch {
+                args = {};
+            }
+        }
+        out.push({ name, arguments: args });
+    }
+    return out.length > 0 ? out : undefined;
+}
+/**
+ * Parse a single newline-delimited JSON line from `/api/chat`. Returns null for
+ * blank lines or unparseable keepalives (never throws). Tolerates both the
+ * streaming shape (`message.content`) and the non-stream shape.
+ */
+export function parseOllamaChatLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return null;
+    let json;
+    try {
+        json = JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+    const msg = json.message;
+    const content = typeof msg?.content === 'string' ? msg.content : '';
+    const done = json.done === true;
+    const out = { content, done };
+    const toolCalls = extractOllamaToolCalls(msg);
+    if (toolCalls)
+        out.toolCalls = toolCalls;
+    if (typeof json.prompt_eval_count === 'number')
+        out.promptTokens = json.prompt_eval_count;
+    if (typeof json.eval_count === 'number')
+        out.completionTokens = json.eval_count;
+    return out;
+}
+/**
+ * Fold a parsed delta into a running accumulator. Pure — no I/O. The caller
+ * feeds each line's parse result here and reads `text` / token counts at the end.
+ */
+export function foldOllamaDelta(acc, delta) {
+    if (!delta)
+        return acc;
+    return {
+        text: acc.text + delta.content,
+        toolCalls: delta.toolCalls ? [...acc.toolCalls, ...delta.toolCalls] : acc.toolCalls,
+        promptTokens: delta.promptTokens ?? acc.promptTokens,
+        completionTokens: delta.completionTokens ?? acc.completionTokens,
+        done: acc.done || delta.done,
+    };
+}
+/**
+ * Split a buffer into complete lines + a trailing remainder. Pure helper so the
+ * stream reader can carry partial lines across chunk boundaries correctly.
+ * Returns { lines, rest } where `rest` is the unfinished tail (no newline yet).
+ */
+export function splitOllamaLines(buffer) {
+    const parts = buffer.split('\n');
+    const rest = parts.pop() ?? '';
+    return { lines: parts, rest };
+}
+export const initialOllamaAccumulator = () => ({ text: '', toolCalls: [], done: false });
+/**
+ * Pull the real context_length out of an `/api/show` response's `model_info`.
+ * The key is architecture-prefixed (e.g. `llama.context_length`,
+ * `qwen2.context_length`), so we scan for any key ending in `.context_length`
+ * (or the bare `context_length`). Pure + tolerant — returns null when absent.
+ */
+export function extractContextLength(showResponse) {
+    const info = showResponse?.model_info;
+    if (!info || typeof info !== 'object')
+        return null;
+    for (const [key, value] of Object.entries(info)) {
+        if ((key === 'context_length' || key.endsWith('.context_length')) && typeof value === 'number' && value > 0) {
+            return value;
+        }
+    }
+    return null;
+}
+// Per-model context-length cache so we hit /api/show at most once per model.
+const contextLengthCache = new Map();
+/**
+ * Fetch a model's real maximum context window via `/api/show`. Cached per model;
+ * returns null on any error (caller falls back to its default). Never throws.
+ */
+export async function getOllamaContextLength(model, ollamaBaseUrl) {
+    if (contextLengthCache.has(model))
+        return contextLengthCache.get(model) ?? null;
+    const base = ollamaBaseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+    try {
+        const res = await fetch(`${base}/api/show`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: model }),
+            signal: AbortSignal.timeout(5000),
+        });
+        if (!res.ok) {
+            contextLengthCache.set(model, null);
+            return null;
+        }
+        const data = await res.json();
+        const ctx = extractContextLength(data);
+        contextLengthCache.set(model, ctx);
+        return ctx;
+    }
+    catch {
+        contextLengthCache.set(model, null);
+        return null;
+    }
+}
+/** Test seam — reset the per-model context cache. */
+export function _clearOllamaContextCache() {
+    contextLengthCache.clear();
+}
+/**
+ * Stream a chat completion from Ollama's native `/api/chat`. Uses node:http to
+ * sidestep undici's connection pooling (which throws AggregateError against
+ * localhost Ollama on Node 24). Parses the newline-JSON stream via the pure
+ * helpers above. Resolves with the full text + token usage.
+ */
+export function streamOllamaNativeChat(opts) {
+    const base = opts.baseUrl.replace(/\/+$/, '').replace(/\/v1$/, '');
+    const url = `${base}/api/chat`;
+    const options = {};
+    if (opts.numCtx && opts.numCtx > 0)
+        options.num_ctx = opts.numCtx;
+    if (typeof opts.temperature === 'number')
+        options.temperature = opts.temperature;
+    // When tools are present, Ollama only emits tool_calls in non-streaming mode
+    // reliably; streaming tool_calls support varies by version. We stream when
+    // there are no tools (plain chat) and fall to non-stream when tools are sent.
+    const useStream = !opts.tools || opts.tools.length === 0;
+    const body = JSON.stringify({
+        model: opts.model,
+        messages: opts.rawMessages ?? opts.messages,
+        stream: useStream,
+        ...(opts.tools && opts.tools.length ? { tools: opts.tools } : {}),
+        ...(Object.keys(options).length ? { options } : {}),
+        ...(opts.keepAlive ? { keep_alive: opts.keepAlive } : {}),
+    });
+    return new Promise((resolve, reject) => {
+        const u = new URL(url);
+        const lib = u.protocol === 'https:' ? https : http;
+        const req = lib.request({
+            hostname: u.hostname,
+            port: u.port,
+            path: u.pathname + u.search,
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) },
+            timeout: opts.timeoutMs ?? 120_000,
+        }, (res) => {
+            if (res.statusCode && res.statusCode >= 400) {
+                let errBody = '';
+                res.on('data', (c) => { errBody += c.toString(); });
+                res.on('end', () => reject(new Error(`Ollama /api/chat ${res.statusCode}: ${errBody.slice(0, 300)}`)));
+                return;
+            }
+            let buffer = '';
+            let acc = initialOllamaAccumulator();
+            const decoder = new TextDecoder();
+            res.on('data', (chunk) => {
+                buffer += decoder.decode(chunk, { stream: true });
+                const { lines, rest } = splitOllamaLines(buffer);
+                buffer = rest;
+                for (const line of lines) {
+                    const delta = parseOllamaChatLine(line);
+                    if (delta?.content)
+                        opts.onChunk?.(delta.content);
+                    acc = foldOllamaDelta(acc, delta);
+                }
+            });
+            res.on('end', () => {
+                // Flush any trailing line (final object often arrives without a newline).
+                const delta = parseOllamaChatLine(buffer);
+                if (delta?.content)
+                    opts.onChunk?.(delta.content);
+                acc = foldOllamaDelta(acc, delta);
+                resolve({ text: acc.text, toolCalls: acc.toolCalls, promptTokens: acc.promptTokens, completionTokens: acc.completionTokens });
+            });
+            res.on('error', reject);
+        });
+        req.on('error', reject);
+        req.on('timeout', () => { req.destroy(new Error('Ollama request timed out')); });
+        req.write(body);
+        req.end();
+    });
+}

package/dist/config/index.d.ts

@@ -54,6 +54,19 @@ interface ConfigSchema {
     rateLimitCommands: number;
     agentMode: AgentMode;
     ollamaUrl: string;
+    /** Route Ollama through its NATIVE /api/chat endpoint instead of the
+     *  OpenAI-compatible /v1 shim. The native endpoint honors num_ctx + keep_alive
+     *  and exposes the model's real context window. OFF by default — opt-in until
+     *  verified against a live Ollama; when off, the existing /v1 path is used
+     *  unchanged so current behavior is preserved. */
+    ollamaNativeApi: boolean;
+    /** How long Ollama keeps the model loaded in memory between requests (e.g.
+     *  "30m", "1h", "-1" for forever). Avoids reload latency every turn. Sent on
+     *  native /api/chat requests (only when ollamaNativeApi is on). Default "30m". */
+    ollamaKeepAlive: string;
+    /** Override num_ctx (context window) for Ollama. 0 = auto-detect the model's
+     *  real max via /api/show. Set a specific number to cap VRAM use. Default 0. */
+    ollamaNumCtx: number;
     customBaseUrl: string;
     agentConfirmation: 'always' | 'dangerous' | 'never';
     agentConfirmDeleteFile: boolean;

package/dist/config/index.js

@@ -144,6 +144,9 @@ function createConfig() {
         model: 'glm-5.1',
         agentMode: 'on',
         ollamaUrl: 'http://localhost:11434',
+        ollamaNativeApi: false,
+        ollamaKeepAlive: '30m',
+        ollamaNumCtx: 0,
         customBaseUrl: '',
         agentConfirmation: 'dangerous',
         agentConfirmDeleteFile: true,

package/dist/config/providers.js

@@ -243,12 +243,13 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', description: 'Most capable Claude model' },
-            { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', description: 'Previous generation Opus' },
+            { id: 'claude-opus-4-8', name: 'Claude Opus 4.8', description: 'Most capable Claude model' },
+            { id: 'claude-opus-4-7', name: 'Claude Opus 4.7', description: 'Previous generation Opus' },
+            { id: 'claude-opus-4-6', name: 'Claude Opus 4.6', description: 'Older generation Opus' },
             { id: 'claude-sonnet-4-6', name: 'Claude Sonnet', description: 'Best balance of speed and intelligence' },
             { id: 'claude-haiku-4-5-20251001', name: 'Claude Haiku', description: 'Fastest and most affordable' },
         ],
-        defaultModel: 'claude-opus-4-7',
+        defaultModel: 'claude-opus-4-8',
         defaultProtocol: 'anthropic',
         envKey: 'ANTHROPIC_API_KEY',
         groupLabel: 'Anthropic',
@@ -266,7 +267,7 @@ export const PROVIDERS = {
         },
         models: [
             { id: 'gemini-3.1-pro-preview', name: 'Gemini 3.1 Pro', description: 'Most capable Gemini model' },
-            { id: 'gemini-3-flash-preview', name: 'Gemini 3 Flash', description: 'Pro-level intelligence at Flash speed' },
+            { id: 'gemini-3.5-flash', name: 'Gemini 3.5 Flash', description: 'Pro-level intelligence at Flash speed' },
         ],
         defaultModel: 'gemini-3.1-pro-preview',
         defaultProtocol: 'openai',

package/dist/renderer/App.js

@@ -94,7 +94,7 @@ const COMMAND_DESCRIPTIONS = {
     'plan': 'Generate a numbered plan for a task — review before /go executes it',
     'go': 'Execute the pending plan from /plan',
     'personality': 'Switch agent tone: concise / verbose / security / senior-reviewer / etc',
-    'me': 'Your user profile (reply language, style, stack) — adapts the agent to you. /me init, /me learn',
+    'me': 'Your user profile (reply language, style, stack) — adapts the agent to you. /me init, /me learn, /me sync',
     'agents': 'List sub-agents the agent can delegate self-contained tasks to (researcher / reviewer / tester / custom)',
     '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)',

package/dist/renderer/commands.js

@@ -93,6 +93,56 @@ export async function handleCommand(command, args, ctx) {
                 });
                 break;
             }
+            // /model browse — curated catalog of recommended local coding models.
+            if (args[0] === 'browse') {
+                const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').toLowerCase();
+                const isLocal = ollamaUrl.includes('localhost') || ollamaUrl.includes('127.0.0.1') || ollamaUrl.includes('[::1]');
+                const { OLLAMA_CODING_MODELS, catalogAgentHint } = await import('../utils/ollamaCatalog.js');
+                const items = OLLAMA_CODING_MODELS.map(m => ({
+                    key: m.pull,
+                    label: m.name,
+                    description: `${m.pull} · ${m.vram} · ${catalogAgentHint(m.params)} — ${m.description}`,
+                }));
+                ctx.app.showSelect('Recommended coding models (pull)', items, '', (item) => {
+                    if (!isLocal) {
+                        ctx.app.notify(`Ollama is on a remote server. SSH in and run: ollama pull ${item.key}`);
+                        return;
+                    }
+                    ctx.app.notify(`Pulling ${item.key}... (this may take a while)`);
+                    import('child_process').then(({ execFile }) => {
+                        execFile('ollama', ['pull', item.key], { timeout: 1_200_000 }, (err) => {
+                            if (err)
+                                ctx.app.notify(`Pull failed: ${err.message}`);
+                            else
+                                ctx.app.notify(`✓ ${item.key} ready — use /model to select it`);
+                        });
+                    });
+                });
+                break;
+            }
+            // /model rm <name> — delete a locally-installed Ollama model.
+            if (args[0] === 'rm' || args[0] === 'remove' || args[0] === 'delete') {
+                const modelName = args[1];
+                if (!modelName) {
+                    ctx.app.notify('Usage: /model rm <model-name>');
+                    break;
+                }
+                const ollamaUrl = (config.get('ollamaUrl') || 'http://localhost:11434').toLowerCase();
+                const isLocal = ollamaUrl.includes('localhost') || ollamaUrl.includes('127.0.0.1') || ollamaUrl.includes('[::1]');
+                if (!isLocal) {
+                    ctx.app.notify(`Ollama is on a remote server. SSH in and run: ollama rm ${modelName}`);
+                    break;
+                }
+                ctx.app.notify(`Removing ${modelName}…`);
+                const { execFile } = await import('child_process');
+                execFile('ollama', ['rm', modelName], { timeout: 60_000 }, (err) => {
+                    if (err)
+                        ctx.app.notify(`Remove failed: ${err.message}`);
+                    else
+                        ctx.app.notify(`✓ Removed ${modelName}`);
+                });
+                break;
+            }
             const providerId = config.get('provider');
             const { isDynamicModelsProvider, isNoApiKeyProvider: _noKey } = await import('../config/providers.js');
             if (isDynamicModelsProvider(providerId)) {
@@ -375,6 +425,26 @@ export async function handleCommand(command, args, ctx) {
                     : 'No learned profile to clear.');
                 break;
             }
+            if (sub === 'sync') {
+                const { getSyncToken } = await import('../config/index.js');
+                if (!getSyncToken()) {
+                    ctx.app.notify('Not linked to codeep.dev. Run: codeep account');
+                    break;
+                }
+                const { pushUserProfile, pullUserProfile } = await import('../utils/codeepCloud.js');
+                ctx.app.notify('Syncing your profile with codeep.dev…');
+                const pushed = await pushUserProfile();
+                const pulled = await pullUserProfile();
+                const lines = [];
+                if (pushed)
+                    lines.push('✓ Profile pushed to the dashboard');
+                if (pulled === 1)
+                    lines.push('✓ Profile pulled to this machine');
+                if (lines.length === 0)
+                    lines.push('Nothing to sync yet — run `/me init` and fill in your profile first.');
+                ctx.app.addMessage({ role: 'system', content: `## Profile sync\n\n${lines.join('\n')}` });
+                break;
+            }
             if (sub === 'init') {
                 const scope = args[1]?.toLowerCase() === 'project' ? 'project' : 'global';
                 if (scope === 'project' && !ctx.projectPath) {

package/dist/renderer/components/Help.js

@@ -131,6 +131,7 @@ export const helpCategories = [
             { key: '/me', description: 'Your user profile (reply language, style, stack) — adapts the agent to you' },
             { key: '/me init [project]', description: 'Scaffold a profile template (global, or for this project). /me off to disable' },
             { key: '/me learn [on|off]', description: 'Learn durable prefs from this session now; on/off toggles auto-learn. /me forget clears it' },
+            { key: '/me sync', description: 'Push your profile to the codeep.dev dashboard (and pull on a fresh machine)' },
             { key: '/agents', description: 'List sub-agents the agent can delegate to (researcher / reviewer / tester / your own)' },
             { key: '/insights [--days N]', description: 'Activity summary — runs, files, tools, projects over the last N days (default 7)' },
         ],
@@ -170,6 +171,8 @@ export const helpCategories = [
             { key: '/settings > Ollama URL', description: 'Set URL (default: http://localhost:11434)' },
             { key: '/model', description: 'Pick installed Ollama model dynamically' },
             { key: '/model pull <model>', description: 'Pull an Ollama model (local Ollama only)' },
+            { key: '/model browse', description: 'Browse recommended local coding models and pull one' },
+            { key: '/model rm <model>', description: 'Remove a locally-installed Ollama model (local only)' },
             { key: 'OLLAMA_HOST=0.0.0.0', description: 'Required env var for remote Ollama access' },
         ],
     },

package/dist/renderer/components/Settings.js

@@ -131,6 +131,28 @@ export const SETTINGS = [
         getValue: () => config.get('ollamaUrl') || 'http://localhost:11434',
         type: 'text',
     },
+    {
+        key: 'ollamaNativeApi',
+        label: 'Ollama Native API (beta)',
+        getValue: () => config.get('ollamaNativeApi'),
+        type: 'select',
+        options: [
+            { value: false, label: 'Off (OpenAI-compatible /v1)' },
+            { value: true, label: 'On — beta: native /api/chat (num_ctx + keep_alive)' },
+        ],
+    },
+    {
+        key: 'ollamaKeepAlive',
+        label: 'Ollama Keep-Alive',
+        getValue: () => String(config.get('ollamaKeepAlive') ?? '30m'),
+        type: 'text',
+    },
+    {
+        key: 'ollamaNumCtx',
+        label: 'Ollama Context (num_ctx, 0=auto)',
+        getValue: () => String(config.get('ollamaNumCtx') ?? 0),
+        type: 'text',
+    },
     {
         key: 'customBaseUrl',
         label: 'Custom Base URL',

package/dist/renderer/main.js

@@ -386,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 keys + personalities + commands from codeep.dev
-  codeep account push   Push local keys + personalities + commands to codeep.dev
+  codeep account sync   Pull keys + personalities + commands + profile from codeep.dev
+  codeep account push   Push local keys + personalities + commands + profile to codeep.dev
   codeep acp          Start ACP server (for Zed editor integration)
   codeep --version    Show version
   codeep --help       Show this help
@@ -427,9 +427,9 @@ Commands (in chat):
                 }
                 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');
+            // Also pull portable personal config — personalities + custom commands +
+            // the user profile. Additive merge (never clobbers local files).
+            const { pullPersonalities, pullCommands, pullUserProfile } = await import('../utils/codeepCloud.js');
             const pCount = await pullPersonalities();
             if (typeof pCount === 'number' && pCount > 0) {
                 console.log(`  Pulled ${pCount} personalit${pCount === 1 ? 'y' : 'ies'}.`);
@@ -438,6 +438,10 @@ Commands (in chat):
             if (typeof cCount === 'number' && cCount > 0) {
                 console.log(`  Pulled ${cCount} custom command${cCount === 1 ? '' : 's'}.`);
             }
+            const profPulled = await pullUserProfile();
+            if (profPulled === 1) {
+                console.log('  Pulled your profile (about you).');
+            }
             console.log('');
             process.exit(0);
         }
@@ -465,8 +469,8 @@ Commands (in chat):
             process.stdout.write(`  Pushing ${count} key${count !== 1 ? 's' : ''} to codeep.dev...`);
             const ok = await pushKeys(keys);
             console.log(ok ? ' done.' : ' failed.');
-            // Also push portable personal config.
-            const { pushPersonalities, pushCommands } = await import('../utils/codeepCloud.js');
+            // Also push portable personal config — personalities + commands + profile.
+            const { pushPersonalities, pushCommands, pushUserProfile } = await import('../utils/codeepCloud.js');
             const pCount = await pushPersonalities();
             if (typeof pCount === 'number' && pCount > 0) {
                 console.log(`  Pushed ${pCount} personalit${pCount === 1 ? 'y' : 'ies'}.`);
@@ -475,6 +479,9 @@ Commands (in chat):
             if (typeof cCount === 'number' && cCount > 0) {
                 console.log(`  Pushed ${cCount} custom command${cCount === 1 ? '' : 's'}.`);
             }
+            if (await pushUserProfile()) {
+                console.log('  Pushed your profile (about you).');
+            }
             console.log('');
             process.exit(ok ? 0 : 1);
         }

package/dist/utils/agentChat.js

@@ -373,6 +373,38 @@ additionalTools) {
                 if (prefs)
                     openRouterExtras.provider = prefs;
             }
+            // Opt-in native Ollama transport for AGENT mode. When `ollamaNativeApi`
+            // is on, route through /api/chat (honors num_ctx + keep_alive + the real
+            // context window) and parse native tool_calls. OFF by default → the /v1
+            // path below runs unchanged. Returns the agent response directly.
+            if (providerId === 'ollama' && config.get('ollamaNativeApi') === true) {
+                const { streamOllamaNativeChat, getOllamaContextLength } = await import('../api/ollamaNative.js');
+                const ollamaUrl = config.get('ollamaUrl') || 'http://localhost:11434';
+                const cfgCtx = Number(config.get('ollamaNumCtx')) || 0;
+                const numCtx = cfgCtx > 0 ? cfgCtx : ((await getOllamaContextLength(model, ollamaUrl)) ?? undefined);
+                const res = await streamOllamaNativeChat({
+                    baseUrl: ollamaUrl,
+                    model,
+                    messages: [],
+                    rawMessages: [{ role: 'system', content: systemPrompt }, ...messages],
+                    tools: getOpenAITools(additionalTools),
+                    numCtx,
+                    keepAlive: config.get('ollamaKeepAlive') || undefined,
+                    temperature: requiresDefaultTemperature(providerId) ? undefined : Number(config.get('temperature')),
+                    timeoutMs,
+                    onChunk: useStreaming ? onChunk : undefined,
+                });
+                if (res.promptTokens != null && res.completionTokens != null) {
+                    recordTokenUsage({ promptTokens: res.promptTokens, completionTokens: res.completionTokens, totalTokens: res.promptTokens + res.completionTokens }, model, providerId);
+                }
+                const toolCalls = res.toolCalls.map((tc) => ({ tool: tc.name, parameters: tc.arguments }));
+                if (toolCalls.length === 0 && res.text) {
+                    const textCalls = parseToolCalls(res.text);
+                    if (textCalls.length > 0)
+                        return { content: res.text, toolCalls: textCalls, usedNativeTools: false };
+                }
+                return { content: res.text, toolCalls, usedNativeTools: true };
+            }
             body = {
                 model, messages: [{ role: 'system', content: systemPrompt }, ...messages],
                 tools: getOpenAITools(additionalTools), tool_choice: 'auto', stream: useStreaming,

package/dist/utils/ollamaCatalog.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Curated catalog of recommended local coding models for Ollama, surfaced via
+ * `/model browse`. Mirrors the MCP catalog pattern: a hand-picked shortlist so
+ * users don't have to hunt ollama.com for good coding models.
+ *
+ * Each entry's `pull` is the exact `ollama pull` tag. `params` is the parameter
+ * count (drives the agent-mode hint — <7B models struggle with tool-calling
+ * loops). `vram` is a rough "comfortable" requirement for the default quant.
+ *
+ * Curated, not exhaustive — users can still `/model pull <anything>`.
+ */
+export interface OllamaCatalogEntry {
+    /** Exact `ollama pull` tag, e.g. "qwen2.5-coder:7b". */
+    pull: string;
+    /** Display name. */
+    name: string;
+    /** Parameter count in billions (for the agent-mode hint). */
+    params: number;
+    /** Rough comfortable RAM/VRAM for the default quantization. */
+    vram: string;
+    /** One-line description. */
+    description: string;
+}
+/**
+ * Recommended coding models. Ordered roughly best-for-agent first within size
+ * tiers. All are real Ollama library tags as of this release.
+ */
+export declare const OLLAMA_CODING_MODELS: OllamaCatalogEntry[];
+/** Agent-mode suitability hint for a catalog entry (≥7B → agent-capable). */
+export declare function catalogAgentHint(params: number): string;

package/dist/utils/ollamaCatalog.js

@@ -0,0 +1,37 @@
+/**
+ * Curated catalog of recommended local coding models for Ollama, surfaced via
+ * `/model browse`. Mirrors the MCP catalog pattern: a hand-picked shortlist so
+ * users don't have to hunt ollama.com for good coding models.
+ *
+ * Each entry's `pull` is the exact `ollama pull` tag. `params` is the parameter
+ * count (drives the agent-mode hint — <7B models struggle with tool-calling
+ * loops). `vram` is a rough "comfortable" requirement for the default quant.
+ *
+ * Curated, not exhaustive — users can still `/model pull <anything>`.
+ */
+/**
+ * Recommended coding models. Ordered roughly best-for-agent first within size
+ * tiers. All are real Ollama library tags as of this release.
+ */
+export const OLLAMA_CODING_MODELS = [
+    // ── Coding-tuned, agent-capable ──────────────────────────────────────────
+    { pull: 'qwen2.5-coder:32b', name: 'Qwen2.5 Coder 32B', params: 32, vram: '~20 GB', description: 'Top open coding model — strong at tool use and multi-file edits' },
+    { pull: 'qwen2.5-coder:14b', name: 'Qwen2.5 Coder 14B', params: 14, vram: '~9 GB', description: 'Great balance of quality and speed for agent work' },
+    { pull: 'qwen2.5-coder:7b', name: 'Qwen2.5 Coder 7B', params: 7, vram: '~5 GB', description: 'Smallest Qwen Coder that still handles agent mode' },
+    { pull: 'deepseek-coder-v2:16b', name: 'DeepSeek Coder V2 16B', params: 16, vram: '~10 GB', description: 'MoE coding model — fast for its quality' },
+    // ── General-purpose, agent-capable ───────────────────────────────────────
+    { pull: 'llama3.1:8b', name: 'Llama 3.1 8B', params: 8, vram: '~5 GB', description: 'Solid all-rounder; reliable tool-calling for its size' },
+    { pull: 'llama3.1:70b', name: 'Llama 3.1 70B', params: 70, vram: '~40 GB', description: 'Large general model — strongest reasoning if you have the VRAM' },
+    { pull: 'mistral-nemo:12b', name: 'Mistral Nemo 12B', params: 12, vram: '~8 GB', description: '128K context general model, good instruction following' },
+    { pull: 'gemma2:9b', name: 'Gemma 2 9B', params: 9, vram: '~6 GB', description: 'Google open model — capable general assistant' },
+    // ── Reasoning ────────────────────────────────────────────────────────────
+    { pull: 'deepseek-r1:14b', name: 'DeepSeek R1 14B', params: 14, vram: '~9 GB', description: 'Reasoning model — thinks before answering; good for hard bugs' },
+    { pull: 'deepseek-r1:8b', name: 'DeepSeek R1 8B', params: 8, vram: '~5 GB', description: 'Smaller reasoning model for modest hardware' },
+    // ── Small / fast (chat-first; weaker at agent loops) ─────────────────────
+    { pull: 'qwen2.5-coder:3b', name: 'Qwen2.5 Coder 3B', params: 3, vram: '~3 GB', description: 'Fast inline completions / chat; light for full agent tasks' },
+    { pull: 'llama3.2:3b', name: 'Llama 3.2 3B', params: 3, vram: '~3 GB', description: 'Tiny + fast; great for quick chat on low-end machines' },
+];
+/** Agent-mode suitability hint for a catalog entry (≥7B → agent-capable). */
+export function catalogAgentHint(params) {
+    return params >= 7 ? '✓ agent mode' : '⚠ chat / completions (small)';
+}

package/dist/utils/tokenTracker.js

@@ -16,6 +16,7 @@ const MODEL_CONTEXT_WINDOWS = {
     'gpt-5.4-mini': 400_000,
     'gpt-5.4-nano': 400_000,
     // Anthropic
+    'claude-opus-4-8': 1_000_000,
     'claude-opus-4-7': 1_000_000,
     'claude-opus-4-6': 1_000_000,
     'claude-sonnet-4-6': 1_000_000,
@@ -25,6 +26,7 @@ const MODEL_CONTEXT_WINDOWS = {
     'deepseek-v4-flash': 1_000_000,
     // Google
     'gemini-3.1-pro-preview': 1_048_576,
+    'gemini-3.5-flash': 1_000_000,
     'gemini-3-flash-preview': 1_000_000,
     // MiniMax
     'MiniMax-M2.7': 204_800,
@@ -50,6 +52,7 @@ const MODEL_PRICING = {
     'gpt-5.4-mini': { inputPer1M: 0.75, outputPer1M: 4.50 },
     'gpt-5.4-nano': { inputPer1M: 0.20, outputPer1M: 1.25 },
     // Anthropic
+    'claude-opus-4-8': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-opus-4-7': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-opus-4-6': { inputPer1M: 5.00, outputPer1M: 25.00 },
     'claude-sonnet-4-6': { inputPer1M: 3.00, outputPer1M: 15.00 },
@@ -59,6 +62,7 @@ const MODEL_PRICING = {
     'deepseek-v4-flash': { inputPer1M: 0.14, outputPer1M: 0.28 },
     // Google
     'gemini-3.1-pro-preview': { inputPer1M: 2.00, outputPer1M: 12.00 },
+    'gemini-3.5-flash': { inputPer1M: 1.50, outputPer1M: 9.00 },
     'gemini-3-flash-preview': { inputPer1M: 0.50, outputPer1M: 3.00 },
     // MiniMax
     'MiniMax-M2.7': { inputPer1M: 0.30, outputPer1M: 1.20 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "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",