codeep 2.18.1 → 2.19.0

package/README.md

@@ -677,9 +677,10 @@ Then call it as `/sec-review src/api/login.ts` (or `/sec` via the alias).
 **Discovery:** `/commands` lists all available templates. Project files shadow
 global files with the same name. Aliases also work for autocomplete.
 
-### Personalities (`/personality`, new in 2.0.3)
+### Personalities and custom bots (`/personality`)
 
-Swap how the agent talks and what it prioritises mid-conversation:
+Built-in personalities change tone and priorities. A structured custom bot can
+also pin a model, restrict runtime tools, and limit where it is available:
 
 ```
 /personality                  # list available
@@ -694,23 +695,56 @@ Six built-in presets: `concise`, `verbose`, `security`, `senior-reviewer`,
 `junior-mentor`, `ship-it`. The active one persists across sessions
 (stored in `~/.codeep/config.json` as `activePersonality`).
 
-**Custom personalities** — drop a Markdown file in
+**Custom bots** — build one in **Dashboard → Agent Studio**, or drop a Markdown
+file in
 `.codeep/personalities/<name>.md` (project) or
 `~/.codeep/personalities/<name>.md` (global):
 
 ```markdown
-# Personality: PR Reviewer
+---
+codeep: custom-bot/v1
+description: Reviews changes without modifying the project.
+model: automatic
+tools: [files, git]
+scope: selected
+projects: [Codeep]
+---
+# PR Reviewer
+
+## Responsibility
+Review the requested change and cite concrete evidence.
+
+## Always
+- Call out untested behavior.
 
-You are reviewing a PR from a junior engineer:
-- Cite line numbers for every concern.
-- Suggest an alternative, don't just flag the problem.
-- Keep tone collaborative, not pedantic.
-- End with one thing the author did well.
+## Never
+- Modify files or publish changes.
+
+## Advanced instructions
+Keep the tone collaborative and end with the highest-risk finding.
 ```
 
-First `# Personality:` line is the display name; the rest is appended
-to the agent's system prompt verbatim when active. Project shadows
-global shadows built-in (by name).
+Portable tool groups are `files`, `terminal`, `tests`, `git`, `web`, and
+`mcp`; unselected groups are removed from the model's runtime and checked
+again before execution. Missing, empty, or malformed `tools` metadata in a v1
+file creates a conversation-only bot. Use
+`scope: all`, `selected`, or `personal`; selected scope matches the project
+directory basename against `projects` (with optional `*` and `?` wildcards).
+An exact `provider/model` applies only to
+that run, while `automatic` inherits the current selection.
+
+Portable v1 fails closed for unclassified capabilities: Skills, delegation,
+and vision are not exposed to structured bots yet. MCP is available only when
+the active ACP session has registered those exact tools.
+
+Legacy prompt-only Markdown remains supported and unrestricted. The older
+section-only Agent Studio format is recognized when it contains
+`Responsibility` plus another standard section; without a Tools section it
+also stays unrestricted until explicitly converted. Invalid structured model
+or scope metadata makes the bot unavailable rather than silently widening its
+runtime. An explicit unsupported `codeep` schema marker is also unavailable;
+it is never reinterpreted as legacy. Project files shadow global files, which
+shadow built-ins with the same name.
 
 ### Activity Insights (`/insights`, new in 2.0.3)
 
@@ -885,10 +919,13 @@ 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).
+A manual `sync` treats the dashboard personality as current. When a changed
+cloud personality replaces a local file, Codeep first saves the local version
+under `~/.codeep/backups/personalities/` and then swaps the new file in
+atomically. Custom commands keep the older **additive** merge and are never
+overwritten by a pull. View and edit custom bots in **Agent Studio**, and prune
+commands under **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

package/dist/acp/commands.js

@@ -2,8 +2,10 @@
 // Slash command handler for ACP sessions.
 // Mirrors CLI commands from renderer/commands.ts but returns plain text
 // responses (no TUI) suitable for streaming back via session/update.
-import { config, getCurrentProvider, getModelsForCurrentProvider, setProvider, setApiKey, isConfigured, listSessionsWithInfo, startNewSession, loadSession, saveSession, initializeAsProject, isManuallyInitializedProject, setProjectPermission, hasWritePermission, hasReadPermission, isTelemetryEnabled, telemetryForcedOffByEnv, isKeySyncEnabled, keySyncForcedOffByEnv, } from '../config/index.js';
+import { config, getCurrentProvider, getModelsForCurrentProvider, setProvider, setApiKey, isConfigured, listSessionsWithInfo, startNewSession, loadSession, saveSession, initializeAsProject, isManuallyInitializedProject, setProjectPermission, hasWritePermission, hasReadPermission, } from '../config/index.js';
 import { getProviderList, getProvider } from '../config/providers.js';
+import { telemetryCommand } from '../commands/core/telemetry.js';
+import { keysyncCommand } from '../commands/core/keysync.js';
 import { getProjectContext } from '../utils/project.js';
 import { loadCustomCommands } from '../utils/customCommands.js';
 import { summarizeHooks } from '../utils/hooks.js';
@@ -210,60 +212,14 @@ export async function handleCommand(input, session, onChunk, abortSignal) {
             return { handled: true, response: await setApiKeyCmd(args[0]) };
         }
         case 'telemetry': {
-            const sub = args[0]?.toLowerCase();
-            const envOff = telemetryForcedOffByEnv();
-            if (sub === 'on' || sub === 'off') {
-                if (envOff) {
-                    return { handled: true, response: 'Telemetry is forced **off** by the `CODEEP_NO_TELEMETRY` / `DO_NOT_TRACK` env var — unset it to change this. The config flag can\'t override an env var.' };
-                }
-                config.set('telemetry', sub === 'on');
-                return {
-                    handled: true,
-                    response: sub === 'on'
-                        ? 'Telemetry **on** — usage stats, session transcripts, progress and memory notes sync to codeep.dev.'
-                        : 'Telemetry **off** — no automatic cloud uploads. Explicit `/account push` still works.',
-                };
-            }
-            if (sub && sub !== 'status') {
-                return { handled: true, response: 'Usage: `/telemetry` · `/telemetry on` · `/telemetry off`' };
-            }
-            const flag = config.get('telemetry') !== false;
-            const lines = [
-                `**Telemetry:** ${isTelemetryEnabled() ? 'on' : 'off'}`,
-                `- Config flag \`telemetry\`: ${flag}`,
-            ];
-            if (envOff)
-                lines.push('- Forced **off** by `CODEEP_NO_TELEMETRY` / `DO_NOT_TRACK` (env overrides the flag).');
-            lines.push('', 'Toggle with `/telemetry on` | `/telemetry off`. Controls automatic uploads of usage stats, session transcripts, progress, and memory notes.');
-            return { handled: true, response: lines.join('\n') };
+            // Core semantics in commands/core/telemetry.ts — this surface only renders.
+            const result = telemetryCommand(args);
+            return { handled: true, response: result.message };
         }
         case 'keysync': {
-            const sub = args[0]?.toLowerCase();
-            const envOff = keySyncForcedOffByEnv();
-            if (sub === 'on' || sub === 'off') {
-                if (envOff) {
-                    return { handled: true, response: 'Cloud key sync is forced **off** by the `CODEEP_NO_KEY_SYNC` env var — unset it to change this. The config flag can\'t override an env var.' };
-                }
-                config.set('syncKeysToCloud', sub === 'on');
-                return {
-                    handled: true,
-                    response: sub === 'on'
-                        ? 'Cloud key sync **on** — `codeep account push`/`sync` will now upload/download API keys. Note: synced keys are stored server-readable on codeep.dev.'
-                        : 'Cloud key sync **off** — API keys stay in your OS keychain only. (`codeep account purge-keys` wipes any keys already on the server.)',
-                };
-            }
-            if (sub && sub !== 'status') {
-                return { handled: true, response: 'Usage: `/keysync` · `/keysync on` · `/keysync off`' };
-            }
-            const flag = config.get('syncKeysToCloud') === true;
-            const lines = [
-                `**Cloud key sync:** ${isKeySyncEnabled() ? 'on' : 'off'}`,
-                `- Config flag \`syncKeysToCloud\`: ${flag}`,
-            ];
-            if (envOff)
-                lines.push('- Forced **off** by `CODEEP_NO_KEY_SYNC` (env overrides the flag).');
-            lines.push('', 'OFF by default — API keys live only in your OS keychain unless enabled. When on, `codeep account push`/`sync` move keys, stored **server-readable** on codeep.dev.');
-            return { handled: true, response: lines.join('\n') };
+            // Core semantics in commands/core/keysync.ts — this surface only renders.
+            const result = keysyncCommand(args);
+            return { handled: true, response: result.message };
         }
         case 'login': {
             const [providerId, apiKey] = args;
@@ -681,7 +637,7 @@ Anything else the agent should know — edge cases, gotchas, things to double-ch
         }
         // ─── Personalities + insights (2.0.3) ─────────────────────────────────────
         case 'personality': {
-            const { formatPersonalityList, findPersonality } = await import('../utils/personalities.js');
+            const { formatPersonalityList, findPersonality, formatPersonalityActivation } = await import('../utils/personalities.js');
             const sub = args[0]?.toLowerCase();
             if (!sub) {
                 return { handled: true, response: formatPersonalityList(session.workspaceRoot) };
@@ -697,7 +653,7 @@ Anything else the agent should know — edge cases, gotchas, things to double-ch
             config.set('activePersonality', p.name);
             return {
                 handled: true,
-                response: `Active personality: **${p.displayName}** (\`${p.name}\`, ${p.scope})\n\n_${p.description}_\n\nClear with \`/personality off\`.`,
+                response: formatPersonalityActivation(p),
             };
         }
         case 'agents': {

package/dist/acp/protocol.d.ts

@@ -268,6 +268,40 @@ export interface ListSessionsResult {
     sessions: AcpSessionInfo[];
     nextCursor?: string | null;
 }
+export interface ListPersonalitiesParams {
+    sessionId: string;
+}
+export interface AcpPersonalityInfo {
+    name: string;
+    displayName: string;
+    description: string;
+    structured: boolean;
+    /** True only when Tools was explicitly declared; [] then means conversation-only. */
+    restrictTools: boolean;
+    scope: 'builtin' | 'project' | 'global';
+    model: string;
+    tools: string[];
+    projectScope: 'all' | 'selected' | 'personal' | 'unspecified';
+    projects: string[];
+    available: boolean;
+}
+export interface ListPersonalitiesResult {
+    personalities: AcpPersonalityInfo[];
+    activePersonality: string | null;
+}
+export interface SetPersonalityParams {
+    sessionId: string;
+    personalityId: string | null;
+}
+export interface SetPersonalityResult {
+    activePersonality: string | null;
+}
+export interface SyncPersonalitiesParams {
+    sessionId: string;
+}
+export interface SyncPersonalitiesResult extends ListPersonalitiesResult {
+    updated: number;
+}
 export interface DeleteSessionParams {
     sessionId: string;
     cwd?: string;

package/dist/acp/server.d.ts

@@ -1,4 +1,5 @@
-import { SessionModeState, SessionConfigOption } from './protocol.js';
+import { SessionModeState, SessionConfigOption, ListPersonalitiesResult } from './protocol.js';
+import { type Personality } from '../utils/personalities.js';
 export declare const AGENT_MODES: SessionModeState;
 /**
  * Format a tool call's parameters into a human-readable object for the
@@ -39,4 +40,8 @@ export declare function providerHasKey(providerId: string): boolean;
  * Exported for unit testing (see server.test.ts).
  */
 export declare function buildConfigOptions(): SessionConfigOption[];
+/** Build the stable Codeep ACP personality extension payload for a workspace. */
+export declare function buildPersonalityListResult(workspaceRoot: string): ListPersonalitiesResult;
+/** Resolve an ACP selection using the same scope/model availability gate as list. */
+export declare function resolvePersonalitySelection(personalityId: unknown, workspaceRoot: string): Personality | null;
 export declare function startAcpServer(): Promise<void>;

package/dist/acp/server.js

@@ -17,10 +17,11 @@ import { autoSaveSession, config, getApiKey, getConfiguredProviders } from '../c
 import { ApiError } from '../api/index.js';
 import { PROVIDERS } from '../config/providers.js';
 import { getCurrentVersion } from '../utils/update.js';
-import { reportStats, syncSession, generateProjectId } from '../utils/codeepCloud.js';
+import { reportStats, syncSession, generateProjectId, pullPersonalities } from '../utils/codeepCloud.js';
 import { getCostBreakdown, getRecordCount, createTokenScope, runWithTokenScope } from '../utils/tokenTracker.js';
 import { isGitRepository } from '../utils/git.js';
 import { getProjectContext } from '../utils/project.js';
+import { findPersonality, isPersonalityAvailable, loadAllPersonalities } from '../utils/personalities.js';
 // ─── Slash commands advertised to Zed ────────────────────────────────────────
 const AVAILABLE_COMMANDS = [
     // Configuration
@@ -58,7 +59,7 @@ const AVAILABLE_COMMANDS = [
     { name: 'plan', description: 'Generate a numbered plan for a task — review before /go executes', input: { hint: '<task>' } },
     { 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: 'personality', description: 'List or switch a personality or structured custom bot', 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 | 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]' } },
@@ -366,6 +367,34 @@ export function buildConfigOptions() {
         },
     ];
 }
+/** Build the stable Codeep ACP personality extension payload for a workspace. */
+export function buildPersonalityListResult(workspaceRoot) {
+    const personalities = loadAllPersonalities(workspaceRoot).map(personality => ({
+        name: personality.name,
+        displayName: personality.displayName,
+        description: personality.description,
+        structured: personality.structured === true,
+        restrictTools: personality.restrictTools === true,
+        scope: personality.scope,
+        model: personality.structured ? (personality.modelPreference ?? 'automatic') : 'automatic',
+        tools: personality.structured ? (personality.tools ?? []) : [],
+        projectScope: personality.projectScope ?? 'unspecified',
+        projects: personality.projects ?? [],
+        available: isPersonalityAvailable(personality, workspaceRoot),
+    }));
+    const configuredActive = config.get('activePersonality') ?? null;
+    const activePersonality = configuredActive && personalities.some(personality => personality.name === configuredActive && personality.available)
+        ? configuredActive
+        : null;
+    return { personalities, activePersonality };
+}
+/** Resolve an ACP selection using the same scope/model availability gate as list. */
+export function resolvePersonalitySelection(personalityId, workspaceRoot) {
+    if (typeof personalityId !== 'string')
+        return null;
+    const personality = findPersonality(personalityId, workspaceRoot);
+    return personality && isPersonalityAvailable(personality, workspaceRoot) ? personality : null;
+}
 // ─── Server ───────────────────────────────────────────────────────────────────
 export function startAcpServer() {
     const transport = new StdioTransport();
@@ -440,6 +469,15 @@ export function startAcpServer() {
             case 'session/list_providers':
                 handleListProviders(req);
                 break;
+            case 'session/list_personalities':
+                handleListPersonalities(req);
+                break;
+            case 'session/set_personality':
+                handleSetPersonality(req);
+                break;
+            case 'session/sync_personalities':
+                handleSyncPersonalities(req);
+                break;
             default:
                 process.stderr.write(`[codeep-acp] Unknown method: ${req.method}\n`);
                 transport.error(req.id, -32601, `Method not found: ${req.method}`);
@@ -783,6 +821,63 @@ export function startAcpServer() {
     function handleListProviders(msg) {
         handleListProvidersExternal(msg, handlerDeps);
     }
+    // ── Codeep personality extensions ─────────────────────────────────────────
+    // These methods are intentionally additive to ACP v1. VS Code can render a
+    // native picker without scraping markdown from `/personality`; clients that
+    // do not know the extension continue using the slash command unchanged.
+    function personalityListResult(sessionId) {
+        const session = sessions.get(sessionId);
+        if (!session)
+            return null;
+        return buildPersonalityListResult(session.workspaceRoot);
+    }
+    function handleListPersonalities(msg) {
+        const params = (msg.params ?? {});
+        const result = personalityListResult(params.sessionId);
+        if (!result) {
+            transport.error(msg.id, -32602, `Unknown sessionId: ${params.sessionId}`);
+            return;
+        }
+        transport.respond(msg.id, result);
+    }
+    function handleSetPersonality(msg) {
+        const params = (msg.params ?? {});
+        const session = sessions.get(params.sessionId);
+        if (!session) {
+            transport.error(msg.id, -32602, `Unknown sessionId: ${params.sessionId}`);
+            return;
+        }
+        if (params.personalityId === null) {
+            config.set('activePersonality', null);
+            const result = { activePersonality: null };
+            transport.respond(msg.id, result);
+            return;
+        }
+        const selected = resolvePersonalitySelection(params.personalityId, session.workspaceRoot);
+        if (!selected) {
+            transport.error(msg.id, -32602, `Personality is unknown or unavailable here: ${String(params.personalityId)}`);
+            return;
+        }
+        const personalityId = params.personalityId.toLowerCase();
+        config.set('activePersonality', personalityId);
+        const result = { activePersonality: personalityId };
+        transport.respond(msg.id, result);
+    }
+    async function handleSyncPersonalities(msg) {
+        const params = (msg.params ?? {});
+        if (!sessions.has(params.sessionId)) {
+            transport.error(msg.id, -32602, `Unknown sessionId: ${params.sessionId}`);
+            return;
+        }
+        const updated = await pullPersonalities();
+        if (updated === null) {
+            transport.error(msg.id, -32001, 'Personality sync failed or this device is not linked to codeep.dev.');
+            return;
+        }
+        const list = personalityListResult(params.sessionId);
+        const result = { updated, ...list };
+        transport.respond(msg.id, result);
+    }
     // ── session/prompt ──────────────────────────────────────────────────────────
     async function handleSessionPrompt(msg) {
         const params = msg.params;

package/dist/api/index.js

@@ -2,6 +2,7 @@ import * as http from 'node:http';
 import * as https from 'node:https';
 import { config, getApiKey, resolveBaseUrl } from '../config/index.js';
 import { withRetry, isNetworkError } from '../utils/retry.js';
+import { checkApiRateLimit } from '../utils/ratelimit.js';
 import { getProvider, getProviderBaseUrl, getProviderAuthHeader, usesMaxCompletionTokens, requiresDefaultTemperature, modelRejectsSamplingParams, reasoningParamsFor } from '../config/providers.js';
 import { logApiRequest, logApiResponse } from '../utils/logger.js';
 import { loadProjectIntelligence, generateContextFromIntelligence } from '../utils/projectIntelligence.js';
@@ -154,6 +155,14 @@ export async function chat(message, history = [], onChunk, onRetry, projectConte
     const protocol = config.get('protocol');
     const model = config.get('model');
     const providerId = config.get('provider');
+    // Global API throttle — the single choke point every surface funnels
+    // through (TUI chat, agent loop, ACP sessions, sub-agents, session
+    // titles). Without this, a runaway agent loop burns provider quota and
+    // hits provider-side 429s with nothing on our side slowing it down.
+    const rateCheck = checkApiRateLimit();
+    if (!rateCheck.allowed) {
+        throw new ApiError(rateCheck.message || 'API rate limit exceeded', 429);
+    }
     const { isNoApiKeyProvider } = await import('../config/providers.js');
     const apiKey = getApiKey() || (isNoApiKeyProvider(providerId) ? 'ollama' : null);
     if (!apiKey) {

package/dist/commands/core/index.d.ts

@@ -0,0 +1,19 @@
+/** Result of executing a core command. Plain data — no UI. */
+export interface CommandResult {
+    /** Outcome for the user, in a presentation-neutral voice. */
+    message: string;
+    /** Severity hints the surface's rendering (banner vs error style). */
+    kind?: 'ok' | 'info' | 'warn' | 'error';
+    /** Optional follow-up action the surface may offer (unused for now). */
+    hint?: string;
+}
+/** Context a core command may need. All fields optional — commands declare
+ *  what they use via their signature, surfaces pass what they have. */
+export interface CoreCommandContext {
+    /** Raw args after the command name (e.g. ['on'] for `/telemetry on`). */
+    args: string[];
+}
+export declare function ok(message: string): CommandResult;
+export declare function info(message: string): CommandResult;
+export declare function warn(message: string): CommandResult;
+export declare function error(message: string): CommandResult;

package/dist/commands/core/index.js

@@ -0,0 +1,28 @@
+// commands/core/index.ts
+// Shared command core — single implementation of command semantics used by
+// BOTH dispatch surfaces (TUI renderer/commands.ts and ACP acp/commands.ts).
+//
+// Problem this solves: ~40 commands are implemented twice with different
+// presentation (TUI: app.notify / interactive pickers; ACP: response
+// strings). Every behavior change had to be made twice, and they drifted.
+//
+// Contract: a core command does validation + state mutation and returns a
+// CommandResult — plain data describing the outcome. The surface adapter
+// (TUI or ACP) renders that result in its own style. Side-effectful UI
+// (pickers, dialogs) stays in the surface layer; pure decisions live here.
+//
+// Migration is incremental: each command moves over one at a time, in its
+// own change, with the old inline branches deleted only once both surfaces
+// call the core.
+export function ok(message) {
+    return { message, kind: 'ok' };
+}
+export function info(message) {
+    return { message, kind: 'info' };
+}
+export function warn(message) {
+    return { message, kind: 'warn' };
+}
+export function error(message) {
+    return { message, kind: 'error' };
+}

package/dist/commands/core/keysync.d.ts

@@ -0,0 +1,2 @@
+import { type CommandResult } from './index';
+export declare function keysyncCommand(args: string[]): CommandResult;

package/dist/commands/core/keysync.js

@@ -0,0 +1,34 @@
+// commands/core/keysync.ts
+// Core semantics of `/keysync` — shared by TUI and ACP dispatch.
+//
+// Single source of truth for: env-forced-off check, config toggle, and the
+// status report facts (including the server-readable-keys disclosure that
+// must always accompany enabling sync).
+import { config, keySyncForcedOffByEnv, isKeySyncEnabled } from '../../config/index.js';
+import { ok, warn, info } from './index.js';
+export function keysyncCommand(args) {
+    const sub = args[0]?.toLowerCase();
+    const envOff = keySyncForcedOffByEnv();
+    if (sub === 'on' || sub === 'off') {
+        if (envOff) {
+            return warn('Cloud key sync is forced off by CODEEP_NO_KEY_SYNC — unset that env var to change it. The config flag can\'t override an env var.');
+        }
+        config.set('syncKeysToCloud', sub === 'on');
+        return ok(sub === 'on'
+            ? 'Cloud key sync on — `codeep account push`/`sync` will now upload/download API keys. Note: synced keys are stored server-readable on codeep.dev.'
+            : 'Cloud key sync off — API keys stay in your OS keychain only. (`codeep account purge-keys` wipes any keys already on the server.)');
+    }
+    if (sub && sub !== 'status') {
+        return info('Usage: /keysync · /keysync on · /keysync off');
+    }
+    const flag = config.get('syncKeysToCloud') === true;
+    const lines = [
+        `Cloud key sync: ${isKeySyncEnabled() ? 'on' : 'off'}`,
+        `- Config flag \`syncKeysToCloud\`: ${flag}`,
+    ];
+    if (envOff) {
+        lines.push('- Forced off by `CODEEP_NO_KEY_SYNC` (env overrides the flag).');
+    }
+    lines.push('', 'OFF by default — API keys live only in your OS keychain unless enabled. When on, `codeep account push`/`sync` move keys, stored server-readable on codeep.dev.');
+    return info(lines.join('\n'));
+}

package/dist/commands/core/telemetry.d.ts

@@ -0,0 +1,2 @@
+import { type CommandResult } from './index';
+export declare function telemetryCommand(args: string[]): CommandResult;

package/dist/commands/core/telemetry.js

@@ -0,0 +1,34 @@
+// commands/core/telemetry.ts
+// Core semantics of `/telemetry` — shared by TUI and ACP dispatch.
+//
+// Single source of truth for: env-forced-off check, config toggle,
+// and the status report facts. Presentation (markdown vs banner) is the
+// surface's job; this returns plain-data CommandResults.
+import { config, isTelemetryEnabled, telemetryForcedOffByEnv } from '../../config/index.js';
+import { ok, warn, info } from './index.js';
+export function telemetryCommand(args) {
+    const sub = args[0]?.toLowerCase();
+    const envOff = telemetryForcedOffByEnv();
+    if (sub === 'on' || sub === 'off') {
+        if (envOff) {
+            return warn('Telemetry is forced off by CODEEP_NO_TELEMETRY / DO_NOT_TRACK — unset that env var to change it. The config flag can\'t override an env var.');
+        }
+        config.set('telemetry', sub === 'on');
+        return ok(sub === 'on'
+            ? 'Telemetry on — usage stats, session transcripts, progress and memory notes sync to codeep.dev.'
+            : 'Telemetry off — no automatic cloud uploads. Explicit /account push still works.');
+    }
+    if (sub && sub !== 'status') {
+        return info('Usage: /telemetry · /telemetry on · /telemetry off');
+    }
+    const flag = config.get('telemetry') !== false;
+    const lines = [
+        `Telemetry: ${isTelemetryEnabled() ? 'on' : 'off'}`,
+        `- Config flag \`telemetry\`: ${flag}`,
+    ];
+    if (envOff) {
+        lines.push('- Forced off by `CODEEP_NO_TELEMETRY` / `DO_NOT_TRACK` (env overrides the flag).');
+    }
+    lines.push('', 'Toggle with `/telemetry on` | `/telemetry off`. Controls automatic uploads of usage stats, session transcripts, progress, and memory notes.');
+    return info(lines.join('\n'));
+}

package/dist/config/index.js

@@ -182,8 +182,8 @@ function createConfig() {
         maxTokens: 32768,
         reasoningEffort: 'auto',
         apiTimeout: 60000,
-        rateLimitApi: 10000,
-        rateLimitCommands: 10000,
+        rateLimitApi: 240, // API requests per minute — generous for a 50-iteration agent, still stops runaway loops
+        rateLimitCommands: 120, // Commands per minute
         projectPermissions: [],
         providerApiKeys: [],
         configuredProviderIds: [],

package/dist/renderer/App.d.ts

@@ -20,37 +20,13 @@ export interface ConfirmOptions {
     onConfirm: () => void;
     onCancel?: () => void;
 }
+export { HunkPickerItem, HunkPickerOptions } from './components/HunkPicker';
+import { type HunkPickerOptions } from './components/HunkPicker';
 /**
- * One hunk in the interactive `/apply --interactive` picker.
- * `lines` are already-formatted diff lines (e.g. `+ added`, `- removed`).
+ * Options for the interactive hunk picker — see components/HunkPicker.ts.
+ * (`onComplete` fires once with the accepted [path, hunkIndex] pairs so the
+ * caller can apply them via `applyHunksToFiles`.)
  */
-export interface HunkPickerItem {
-    /** File path this hunk belongs to. */
-    path: string;
-    /** 0-based hunk index within the file diff. */
-    hunkIndex: number;
-    /** Human-readable hunk header, e.g. `@@ -12,3 +12,5 @@`. */
-    header: string;
-    /** Pre-formatted diff lines to display. */
-    lines: string[];
-}
-/**
- * Options for the interactive hunk picker. The picker walks the user
- * through `items` one at a time; for each they accept (`y`/Enter) or
- * skip (`n`). `a` accepts all remaining, `q`/Esc quits.
- *
- * `onComplete` fires once with the set of accepted `[path, hunkIndex]`
- * pairs (possibly empty) so the caller can apply them via
- * `applyHunksToFiles`.
- */
-export interface HunkPickerOptions {
-    title: string;
-    items: HunkPickerItem[];
-    onComplete: (accepted: Array<{
-        path: string;
-        hunkIndex: number;
-    }>) => void;
-}
 export interface AppOptions {
     onSubmit: (message: string) => Promise<void>;
     onCommand: (command: string, args: string[]) => void;
@@ -93,30 +69,19 @@ export declare class App {
     private appStartedAt;
     /** Start of the current agent run; unlike app uptime, resets per task. */
     private agentStartedAt;
-    private pasteInfo;
-    private pasteInfoOpen;
+    private pasteDialog;
     private codeBlockCounter;
     private messageCache;
     private helpOpen;
     private helpScrollIndex;
     private statusOpen;
     private settingsState;
-    private showAutocomplete;
-    private autocompleteIndex;
-    private autocompleteItems;
-    private showMentionAutocomplete;
-    private mentionIndex;
-    private mentionItems;
-    private mentionAtStart;
-    /** Project root for resolving `suggestMentions`. Cached per update. */
-    private mentionRoot;
+    private autocomplete;
+    private mention;
     private confirmOpen;
     private confirmOptions;
     private confirmSelection;
-    private hunkPickerOpen;
-    private hunkPickerOptions;
-    private hunkPickerIndex;
-    private hunkPickerAccepted;
+    private hunkPicker;
     private menuOpen;
     private menuTitle;
     /** Filtered view shown to the user; derived from `menuItemsAll` + `menuFilter`. */
@@ -449,10 +414,6 @@ export declare class App {
      * Render inline confirmation dialog below status bar
      */
     private renderInlineConfirm;
-    /**
-     * Render inline hunk picker (`/apply --interactive`).
-     * Shows the current hunk's diff + the y/n/a/q key legend.
-     */
     private renderInlineHunkPicker;
     /**
      * Render input line