codeep 2.1.4 → 2.3.0

package/README.md

@@ -13,7 +13,7 @@
 </p>
 
 <p align="center">
-  AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.
+  Autonomous AI coding agent that reads your project, runs commands, and writes &amp; verifies code — deeper than autocomplete. Any model (Claude, Gemini, DeepSeek, GLM, OpenAI, or your own local/custom), in the terminal and your editor.
 </p>
 
 <p align="center">
@@ -242,6 +242,50 @@ Agent learns your coding preferences:
 - Preferred libraries
 - Custom rules you define
 
+### User Profile (`/me`)
+A durable, human-readable description of **you** that Codeep injects into the agent's context on every run — so it adapts to how you work (reply language, response style, default stack, "always / never" rules). It flows to every surface (terminal, VS Code, Zed) since they share the same files.
+
+Two layers:
+- **`~/.codeep/profile.md`** — global: who you are across all projects
+- **`.codeep/profile.md`** — project: your role, goals, and constraints for this repo
+
+Commands:
+- `/me` — view your profile + status
+- `/me init [project]` — scaffold a template to fill in
+- `/me on` / `/me off` — toggle injection
+- `/me learn [on|off]` — opt-in auto-learn: Codeep extracts durable preferences from sessions and merges them into `profile.learned.md` (kept separate from your hand-written file). Off by default.
+- `/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**.
+
+### 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.
+
+Built-ins:
+- **`planner`** — read-only; investigates, then returns a step-by-step implementation plan
+- **`researcher`** — read-only; explores the codebase/web and returns a tight, cited summary
+- **`reviewer`** — read-only; senior review for correctness, security, and design
+- **`tester`** — writes and runs tests, iterates to green
+
+Run `/agents` to list them. The agent invokes them itself via the `delegate` tool (you'll see `⤷ <agent>: …` lines). Add your own with a frontmatter `.md` in `.codeep/agents/<name>.md` (project) or `~/.codeep/agents/<name>.md` (global):
+
+```markdown
+---
+name: migrator
+description: Writes and runs database migrations
+tools: [read_file, write_file, edit_file, execute_command]   # allowlist; omit = all
+model: glm-5.1            # optional override
+personality: senior-reviewer   # optional preset
+maxIterations: 12         # optional budget
+---
+You write safe, reversible DB migrations…
+```
+
+`tools` is an allowlist enforced at dispatch (a `researcher` literally can't write files). Sub-agents inherit your profile + project rules, and their changes are covered by `/undo`.
+
+**Guaranteed review:** enable **Agent Auto-Review** in `/settings` (`agentAutoReview`) and after any run that changes files, Codeep automatically delegates to the `reviewer` and appends its findings — a review stage that always happens. Off by default.
+
 ### Project Rules
 Define project-specific instructions that the AI always follows. Create a rules file in your project root:
 

package/dist/acp/commands.js

@@ -644,6 +644,61 @@ Anything else the agent should know — edge cases, gotchas, things to double-ch
                 response: `Active personality: **${p.displayName}** (\`${p.name}\`, ${p.scope})\n\n_${p.description}_\n\nClear with \`/personality off\`.`,
             };
         }
+        case 'agents': {
+            const { formatAgentList } = await import('../utils/agents.js');
+            return { handled: true, response: formatAgentList(session.workspaceRoot) };
+        }
+        case 'me': {
+            const { formatProfileView, scaffoldProfile, updateLearnedProfile, clearLearnedProfile, } = await import('../utils/userProfile.js');
+            const sub = args[0]?.toLowerCase();
+            if (sub === 'on' || sub === 'off') {
+                config.set('userProfile', sub === 'on');
+                return { handled: true, response: sub === 'on'
+                        ? "Profile injection on — your profile is added to the agent's context."
+                        : 'Profile injection off — profile is saved but not used.', configOptionsChanged: true };
+            }
+            if (sub === 'init') {
+                const scope = args[1]?.toLowerCase() === 'project' ? 'project' : 'global';
+                if (scope === 'project' && !session.workspaceRoot) {
+                    return { handled: true, response: 'No project here — use `/me init` for a global profile.' };
+                }
+                const res = scaffoldProfile(scope, session.workspaceRoot);
+                if (!res)
+                    return { handled: true, response: 'Could not create the profile file.' };
+                return { handled: true, response: res.created
+                        ? `Created ${scope} profile: \`${res.path}\` — edit it and Codeep uses it automatically.`
+                        : `${scope === 'global' ? 'Global' : 'Project'} profile already exists: \`${res.path}\`.` };
+            }
+            if (sub === 'learn') {
+                const arg = args[1]?.toLowerCase();
+                if (arg === 'on' || arg === 'off') {
+                    config.set('autoLearnProfile', arg === 'on');
+                    return { handled: true, response: arg === 'on'
+                            ? 'Auto-learn on — Codeep updates your learned profile (global + project) from sessions.'
+                            : 'Auto-learn off — Codeep stops updating the learned profile.', configOptionsChanged: true };
+                }
+                const scope = arg === 'project' ? 'project' : 'global';
+                if (scope === 'project' && !session.workspaceRoot) {
+                    return { handled: true, response: 'No project here — run `/me learn` for your global profile.' };
+                }
+                if (session.history.filter((m) => m.role !== 'system').length < 2) {
+                    return { handled: true, response: 'Not enough conversation yet to learn from.' };
+                }
+                const res = await updateLearnedProfile(session.history, scope, session.workspaceRoot);
+                if (!res)
+                    return { handled: true, response: 'Nothing durable to learn right now (or the model call failed).' };
+                const file = scope === 'global' ? '~/.codeep/profile.learned.md' : '.codeep/profile.learned.md';
+                return { handled: true, response: res.updated
+                        ? `Updated your ${scope} learned profile (\`${file}\`):\n\n${res.facts}`
+                        : `No changes — your ${scope} learned profile already covers this:\n\n${res.facts}` };
+            }
+            if (sub === 'forget') {
+                return { handled: true, response: clearLearnedProfile(session.workspaceRoot)
+                        ? 'Cleared the auto-learned profile(s).'
+                        : 'No learned profile to clear.' };
+            }
+            return { handled: true, response: formatProfileView(session.workspaceRoot) };
+        }
         case 'insights': {
             const { formatInsights } = await import('../utils/insights.js');
             let days = 7;
@@ -1375,6 +1430,8 @@ function buildHelp() {
         '| Command | Description |',
         '|---------|-------------|',
         '| `/memory <note>` | Add a project note (or `list` / `remove <n>` / `clear`) |',
+        '| `/me` | Your user profile — reply language, style, stack (`init [project]`, `learn [on\\|off\\|project]`, `forget`, `on`/`off`) |',
+        '| `/agents` | List sub-agents the agent can delegate self-contained tasks to |',
         '| `/profile save <name>` | Save current provider/model/settings (or `load` / `delete` / `list`) |',
         '| `/hooks` | List installed lifecycle hooks (`.codeep/hooks/<event>.sh`) |',
         '',

package/dist/acp/server.js

@@ -58,6 +58,8 @@ 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: '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
     { name: 'scan', description: 'Scan project structure and generate summary' },
@@ -769,7 +771,9 @@ export function startAcpServer() {
         }
         else if (configId === 'agentConfirmDeleteFile' ||
             configId === 'agentConfirmExecuteCommand' ||
-            configId === 'agentConfirmWriteFile') {
+            configId === 'agentConfirmWriteFile' ||
+            configId === 'userProfile' ||
+            configId === 'autoLearnProfile') {
             // Accept boolean or "true"/"false" string from Zed/VSCode
             const bool = value === true || value === 'true';
             config.set(configId, bool);

package/dist/config/index.d.ts

@@ -32,6 +32,16 @@ interface ConfigSchema {
      *  discarding them — so long sessions keep early decisions/constraints.
      *  Default true; set false to fall back to plain truncation (no extra call). */
     autoSummarizeHistory: boolean;
+    /** Inject the user profile (`~/.codeep/profile.md` + project
+     *  `.codeep/profile.md`) into the agent's system prompt so it adapts to the
+     *  user (reply language, style, stack, preferences). Default true; set false
+     *  to keep the profile files but stop injecting them. Managed via `/me`. */
+    userProfile: boolean;
+    /** Auto-learn: at session save, run one LLM pass to extract durable facts /
+     *  preferences about the user and merge them into `~/.codeep/profile.learned.md`
+     *  (injected alongside the hand-written profile). OFF by default — opt in via
+     *  `/me learn on`. Throttled + single-flight so it doesn't spam API calls. */
+    autoLearnProfile: boolean;
     /** Absolute workspace roots whose project-local `.codeep/hooks/*` the user
      *  has approved to run. Untrusted projects' hooks are skipped (a cloned repo
      *  can't execute shell on first tool call). Granted via `/hooks trust`. */
@@ -52,6 +62,10 @@ interface ConfigSchema {
     agentAutoCommit: boolean;
     agentAutoCommitBranch: boolean;
     agentAutoVerify: 'off' | 'build' | 'typecheck' | 'test' | 'all';
+    /** After a top-level agent run that changed files, delegate to the `reviewer`
+     *  sub-agent and append its findings — a guaranteed review stage. Default
+     *  false (opt-in); one extra nested LLM pass when on. */
+    agentAutoReview: boolean;
     agentMaxFixAttempts: number;
     agentMaxIterations: number;
     agentMaxDuration: number;

package/dist/config/index.js

@@ -152,6 +152,7 @@ function createConfig() {
         agentAutoCommit: false,
         agentAutoCommitBranch: false,
         agentAutoVerify: 'off',
+        agentAutoReview: false,
         // One fix attempt is enough for modern models — if verification fails twice
         // with the same approach, the agent usually needs human input, not more loops.
         agentMaxFixAttempts: 1,
@@ -168,6 +169,8 @@ function createConfig() {
         autoSave: true,
         autoSessionTitle: true,
         autoSummarizeHistory: true,
+        userProfile: true,
+        autoLearnProfile: false,
         trustedHookProjects: [],
         currentSessionId: '',
         temperature: 0.7,
@@ -182,6 +185,19 @@ function createConfig() {
         syncToken: '',
         deviceId: '',
     };
+    // Test/CI isolation: when CODEEP_CONFIG_DIR is set, keep config in that
+    // directory (one per test worker) so parallel workers don't race on a shared
+    // on-disk config file (e.g. clobbering trustedHookProjects). Never set in
+    // normal use, so the production resolution below is unchanged.
+    const overrideDir = process.env.CODEEP_CONFIG_DIR;
+    if (overrideDir) {
+        try {
+            return new Conf({ projectName: 'codeep', cwd: overrideDir, defaults });
+        }
+        catch {
+            // fall through to standard resolution
+        }
+    }
     // First try standard location
     try {
         const standardConfig = new Conf({
@@ -686,6 +702,16 @@ export function saveSession(name, history, projectPath) {
             && history.filter(m => m.role !== 'system').length >= 3) {
             void maybeGenerateSessionTitle(name, projectPath).catch(() => { });
         }
+        // Fire-and-forget: when the user opted into profile learning, observe the
+        // session and merge durable facts into ~/.codeep/profile.learned.md.
+        // Throttled + single-flight inside maybeLearnUserProfile, so the 5s
+        // autosave cadence doesn't spawn an LLM call every tick. Default off.
+        if (config.get('autoLearnProfile') === true
+            && history.filter(m => m.role !== 'system').length >= 4) {
+            void import('../utils/userProfile.js')
+                .then(({ maybeLearnUserProfile }) => maybeLearnUserProfile(name, history, projectPath))
+                .catch(() => { });
+        }
         return true;
     }
     catch (error) {

package/dist/renderer/App.js

@@ -94,6 +94,8 @@ 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',
+    '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)',
 };
@@ -241,6 +243,10 @@ export class App {
         'personality', 'insights',
         // 2.1.0 — cross-session recall.
         'recall',
+        // 2.2.0 — user profile.
+        'me',
+        // 2.3.0 — sub-agents / delegation.
+        'agents',
         'c', 't', 'd', 'r', 'f', 'e', 'o', 'b', 'p',
     ];
     constructor(options) {

package/dist/renderer/commands.js

@@ -252,6 +252,9 @@ export async function handleCommand(command, args, ctx) {
                 commands: 'https://codeep.dev/docs/commands#custom-commands',
                 openrouter: 'https://codeep.dev/docs/providers#openrouter',
                 memory: 'https://codeep.dev/docs/commands#intelligence',
+                me: 'https://codeep.dev/docs/agent#user-profile',
+                agents: 'https://codeep.dev/docs/agent#sub-agents',
+                delegate: 'https://codeep.dev/docs/agent#sub-agents',
                 profile: 'https://codeep.dev/docs/commands#settings',
                 compact: 'https://codeep.dev/docs/commands#session',
                 cost: 'https://codeep.dev/docs/dashboard',
@@ -311,6 +314,90 @@ export async function handleCommand(command, args, ctx) {
             });
             break;
         }
+        case 'agents': {
+            // List sub-agents the agent can `delegate` to (built-in + .codeep/agents/).
+            const { formatAgentList } = await import('../utils/agents.js');
+            ctx.app.addMessage({ role: 'system', content: formatAgentList(ctx.projectPath) });
+            break;
+        }
+        case 'me': {
+            // User profile (global ~/.codeep/profile.md + project .codeep/profile.md)
+            // injected into the agent's context. NOT the provider-profile feature
+            // (that's `/profile`). See src/utils/userProfile.ts.
+            const { formatProfileView, scaffoldProfile, updateLearnedProfile, clearLearnedProfile } = await import('../utils/userProfile.js');
+            const sub = args[0]?.toLowerCase();
+            if (sub === 'on' || sub === 'off') {
+                config.set('userProfile', sub === 'on');
+                ctx.app.notify(sub === 'on'
+                    ? "Profile injection on — your profile is added to the agent's context."
+                    : 'Profile injection off — profile is saved but not used.');
+                break;
+            }
+            if (sub === 'learn') {
+                const arg = args[1]?.toLowerCase();
+                if (arg === 'on' || arg === 'off') {
+                    config.set('autoLearnProfile', arg === 'on');
+                    ctx.app.notify(arg === 'on'
+                        ? 'Auto-learn on — Codeep quietly updates your learned profile (global + project) from sessions.'
+                        : 'Auto-learn off — Codeep stops updating the learned profile.');
+                    break;
+                }
+                // Manual one-off. `/me learn project` targets this repo; otherwise global.
+                const scope = arg === 'project' ? 'project' : 'global';
+                if (scope === 'project' && !ctx.projectPath) {
+                    ctx.app.notify('No project detected here — open a project, or run /me learn for your global profile.');
+                    break;
+                }
+                const { loadSession } = await import('../config/index.js');
+                const history = loadSession(ctx.sessionId, ctx.projectPath) || [];
+                if (history.filter((m) => m.role !== 'system').length < 2) {
+                    ctx.app.notify('Not enough conversation yet to learn from — chat a bit, then run /me learn.');
+                    break;
+                }
+                ctx.app.notify(`Learning ${scope} preferences from this session…`);
+                const res = await updateLearnedProfile(history, scope, ctx.projectPath);
+                if (!res) {
+                    ctx.app.notify('Nothing durable to learn right now (or the model call failed).');
+                    break;
+                }
+                const file = scope === 'global' ? '~/.codeep/profile.learned.md' : '.codeep/profile.learned.md';
+                ctx.app.addMessage({
+                    role: 'system',
+                    content: res.updated
+                        ? `Updated your ${scope} learned profile (\`${file}\`):\n\n${res.facts}\n\nClear it anytime with \`/me forget\`.`
+                        : `No changes — your ${scope} learned profile already covers this:\n\n${res.facts}`,
+                });
+                break;
+            }
+            if (sub === 'forget') {
+                ctx.app.notify(clearLearnedProfile(ctx.projectPath)
+                    ? 'Cleared the auto-learned profile(s).'
+                    : 'No learned profile to clear.');
+                break;
+            }
+            if (sub === 'init') {
+                const scope = args[1]?.toLowerCase() === 'project' ? 'project' : 'global';
+                if (scope === 'project' && !ctx.projectPath) {
+                    ctx.app.notify('No project detected here. Use /me init for a global profile, or open a project first.');
+                    break;
+                }
+                const res = scaffoldProfile(scope, ctx.projectPath);
+                if (!res) {
+                    ctx.app.notify('Could not create the profile file.');
+                    break;
+                }
+                ctx.app.addMessage({
+                    role: 'system',
+                    content: res.created
+                        ? `Created ${scope} profile: \`${res.path}\`\n\nEdit it in your editor — Codeep uses it automatically. View anytime with \`/me\`.`
+                        : `${scope === 'global' ? 'Global' : 'Project'} profile already exists: \`${res.path}\`\n\nEdit it directly, or view it with \`/me\`.`,
+                });
+                break;
+            }
+            // Default: show the profile view.
+            ctx.app.addMessage({ role: 'system', content: formatProfileView(ctx.projectPath) });
+            break;
+        }
         case 'plan': {
             // Plan mode: ask the model for a plan, surface it, hold as pending.
             // The user runs /go to execute or /plan <revised> to revise. See
@@ -1799,6 +1886,15 @@ Describe what this skill does. The agent reads this body verbatim when it invoke
                         results.push(`✓ ${pulled} new profile(s) pulled`);
                 }
             }
+            // Sync the hand-written user profile (~/.codeep/profile.md). Push sends
+            // the local file; pull is additive (writes only if no local profile).
+            if (subCmd === 'all' || subCmd === 'profile') {
+                const { pushUserProfile, pullUserProfile } = await import('../utils/codeepCloud.js');
+                if (await pushUserProfile())
+                    results.push('✓ Your profile (about you) pushed');
+                if ((await pullUserProfile()) === 1)
+                    results.push('✓ Your profile pulled to this machine');
+            }
             ctx.app.addMessage({
                 role: 'system',
                 content: `## Sync\n\n${results.map(r => `- ${r}`).join('\n')}`,

package/dist/renderer/components/Help.js

@@ -128,6 +128,10 @@ export const helpCategories = [
             { key: '/openrouter', description: 'OpenRouter routing prefs (prefer/ignore providers, fallbacks, privacy)' },
             { key: '/personality', description: 'List or switch agent tone (concise / verbose / security / senior-reviewer / …)' },
             { key: '/personality <name>', description: 'Activate a personality. /personality off to clear.' },
+            { 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: '/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)' },
         ],
     },

package/dist/renderer/components/Settings.js

@@ -179,6 +179,16 @@ export const SETTINGS = [
             { value: 'all', label: 'Build + Typecheck + Test' },
         ],
     },
+    {
+        key: 'agentAutoReview',
+        label: 'Agent Auto-Review',
+        getValue: () => config.get('agentAutoReview'),
+        type: 'select',
+        options: [
+            { value: true, label: 'On (reviewer pass after changes)' },
+            { value: false, label: 'Off' },
+        ],
+    },
     {
         key: 'agentAutoCommit',
         label: 'Agent Auto-Commit',

package/dist/utils/agent.d.ts

@@ -56,6 +56,20 @@ export interface AgentOptions {
         role: 'user' | 'assistant';
         content: string;
     }>;
+    /** Delegated sub-agent run. Skips the undo/history session + progress log so
+     *  it doesn't clobber the parent's (history.ts uses a module-level
+     *  `currentSession` singleton — a nested startSession would reset it). The
+     *  sub-agent's tool actions still record into the parent's session, so undo
+     *  spans delegation. */
+    nested?: boolean;
+    /** Delegation depth. 0 = top-level orchestrator (gets the `delegate` tool);
+     *  sub-agents run at depth 1 and cannot delegate further (v1). */
+    depth?: number;
+    /** Tool allowlist for a scoped sub-agent. Undefined = all tools. Enforced at
+     *  dispatch — a disallowed tool call returns an error result. */
+    allowedTools?: string[];
+    /** Role system-prompt addendum injected for a delegated sub-agent. */
+    roleAddendum?: string;
 }
 export interface AgentResult {
     success: boolean;