feat: implement user profile sync functionality

- Added functions to push and pull user profiles to/from the dashboard.
- Implemented additive profile syncing to prevent local data loss.
- Created userProfile.ts for managing user profiles and auto-learning features.
- Added tests for user profile functionalities and agent management.
- Introduced agents.ts to define and manage sub-agent behaviors.
- Enhanced vitest configuration to support setup files for isolated test environments.

Author: VladoIvankovic

CHANGELOG.md

@@ -11,6 +11,60 @@ For releases before v1.3.35, see [GitHub Releases](https://github.com/VladoIvank
 > as the social-share summary (IFTTT → X/Bluesky), capped at 220 chars.
 > If omitted, the feed falls back to the first paragraph.
 
+## [2.3.0] — 2026-05-25
+
+> Codeep gets personal and gains a team: a **user profile** (`/me`) makes it adapt to you across every surface, and **multi-agent delegation** lets it hand self-contained sub-tasks to specialist sub-agents that run in their own context.
+
+### Added — Personalization
+
+- **User profile (`/me`).** A durable, human-readable description of you, injected
+  into the agent's system prompt on every run so it adapts to how you work
+  without you repeating yourself. Two scopes: global `~/.codeep/profile.md`
+  (reply language, response style, default stack, universal "always / never")
+  and project `.codeep/profile.md` (your role, goals, constraints for this repo).
+  Manage with `/me`, `/me init [project]`, and `/me on` / `/me off`. Flows to
+  every surface because they share the same files.
+- **Opt-in profile auto-learn.** `/me learn on` lets Codeep quietly extract your
+  durable preferences from sessions — one cheap, throttled LLM pass at session
+  save — and merge them into a separate `profile.learned.md` (global + project),
+  kept apart from your hand-written file so it's never clobbered. `/me learn`
+  runs it once on demand, `/me learn project` scopes to this repo, `/me forget`
+  clears it. Off by default; gated by `autoLearnProfile`.
+- **Profile sync.** `codeep account sync` pushes your global `profile.md` to the
+  codeep.dev dashboard (where it's editable) and pulls it to new machines. Pull
+  is additive — a web edit never overwrites an existing local profile.
+- **`/me` in ACP.** Zed, VS Code, and any ACP client can view and manage the
+  profile, not just the terminal.
+
+### Added — Multi-agent delegation
+
+- **Sub-agents + the `delegate` tool.** The agent can delegate a self-contained
+  sub-task to a specialist that runs in its OWN fresh context window and returns
+  only a summary — so the main context stays small and each sub-task runs with a
+  tuned persona and a scoped toolset. Four built-ins: `planner` (read-only
+  planning), `researcher` (read-only explorer), `reviewer` (read-only senior
+  review), `tester` (writes + runs tests). Run `/agents` to list them.
+- **Custom sub-agents.** Define your own with a frontmatter `.md` in
+  `.codeep/agents/<name>.md` (project) or `~/.codeep/agents/` (global): name,
+  description, a `tools` allowlist, optional `model` override, `personality`
+  preset, and `maxIterations` budget. Mirrors the personalities/skills pattern.
+- **Auto-review pipeline.** Enable **Agent Auto-Review** (`agentAutoReview`, off
+  by default) and after any run that changes files, Codeep automatically
+  delegates to the `reviewer` and appends its findings — a review stage that
+  always happens, without relying on the model to self-delegate one.
+- **`/agents`** surfaced in the TUI and ACP (Zed / VS Code).
+
+### Notes
+
+- Profile is local-first and opt-in: injection is gated by `userProfile` (default
+  on), auto-learn by `autoLearnProfile` (default off). Nothing reaches the
+  dashboard unless you run `codeep account sync`.
+- Sub-agent tool scoping is enforced at dispatch — a `researcher` can't write
+  files even if it tries. Sub-agents inherit your profile, project rules, and
+  permission prompts, and their file changes are covered by `/undo` (they record
+  into the parent's session). Delegation depth is capped at 1; model overrides
+  are sequential-safe.
+
 ## [2.1.4] — 2026-05-22
 
 > Long agent runs no longer silently forget how they started — when prior chat history overflows the context budget, the dropped older messages are summarized instead of just truncated. Plus a command-whitelist hardening.

README.md

@@ -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.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "2.1.4",
+  "version": "2.3.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",

src/acp/commands.ts

@@ -728,6 +728,64 @@ Anything else the agent should know — edge cases, gotchas, things to double-ch
       };
     }
 
+    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;
@@ -1505,6 +1563,8 @@ function buildHelp(): string {
     '| 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`) |',
     '',

src/acp/server.ts

@@ -80,6 +80,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' },
@@ -811,7 +813,9 @@ export function startAcpServer(): Promise<void> {
     } 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';

src/config/index.ts

@@ -61,6 +61,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`. */
@@ -81,6 +91,10 @@ interface ConfigSchema {
   agentAutoCommit: boolean; // Auto-commit after agent completes
   agentAutoCommitBranch: boolean; // Create new branch for commits
   agentAutoVerify: 'off' | 'build' | 'typecheck' | 'test' | 'all'; // Auto-run verification after changes
+  /** 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; // Max attempts to fix errors (default: 1)
   agentMaxIterations: number; // Max agent iterations (default: 50)
   agentMaxDuration: number; // Max agent duration in minutes (default: 20)
@@ -271,6 +285,7 @@ function createConfig(): Conf<ConfigSchema> {
     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,
@@ -287,6 +302,8 @@ function createConfig(): Conf<ConfigSchema> {
     autoSave: true,
     autoSessionTitle: true,
     autoSummarizeHistory: true,
+    userProfile: true,
+    autoLearnProfile: false,
     trustedHookProjects: [],
     currentSessionId: '',
     temperature: 0.7,
@@ -302,6 +319,19 @@ function createConfig(): Conf<ConfigSchema> {
     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<ConfigSchema>({ projectName: 'codeep', cwd: overrideDir, defaults });
+    } catch {
+      // fall through to standard resolution
+    }
+  }
+
   // First try standard location
   try {
     const standardConfig = new Conf<ConfigSchema>({
@@ -862,6 +892,17 @@ export function saveSession(name: string, history: Message[], projectPath?: stri
         && 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) {
     logSession('save', name, false);

src/renderer/App.ts

@@ -108,6 +108,8 @@ const COMMAND_DESCRIPTIONS: Record<string, string> = {
   '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)',
 };
@@ -308,6 +310,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',
   ];