codeep 2.0.2 → 2.0.4

package/README.md

@@ -526,6 +526,64 @@ 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)
+
+Swap how the agent talks and what it prioritises mid-conversation:
+
+```
+/personality                  # list available
+/personality concise          # short answers, no preamble
+/personality security         # treat every input as hostile
+/personality senior-reviewer  # push back on shortcuts, name things well
+/personality ship-it          # pick first reasonable approach
+/personality off              # back to default tone
+```
+
+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
+`.codeep/personalities/<name>.md` (project) or
+`~/.codeep/personalities/<name>.md` (global):
+
+```markdown
+# Personality: PR Reviewer
+
+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.
+```
+
+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).
+
+### Activity Insights (`/insights`, new in 2.0.3)
+
+Summarise what the agent has actually done for you over a window — runs,
+tool actions, projects touched, most-edited files — sourced from
+`~/.codeep/history/<id>.json` (one file per agent run, automatic).
+
+```
+/insights                 # last 7 days (default)
+/insights --days 30       # last month
+/insights --days 1        # today only
+```
+
+Surfaces (markdown rendered in chat):
+
+- Headline tally: runs · actions · active time · active-days density · avg actions/run
+- **By project** sorted by active time
+- **Top tools** (read_file × 340, write_file × 80, …)
+- **Most-touched files** (with `~` prefix for readability)
+- **Recent runs** — 10 most recent with project, duration, and the user prompt that started them
+
+Cost / token usage isn't in `/insights` (it lives in `/cost` per-session
+since the token tracker is in-memory). Insights is history-only.
+
 ### Project Intelligence (`/init`, `/scan`)
 
 Initialize a project and scan it once to cache deep analysis for faster AI responses:

package/dist/acp/commands.js

@@ -600,6 +600,45 @@ Anything else the agent should know — edge cases, gotchas, things to double-ch
             }
         }
         // ─── Export ────────────────────────────────────────────────────────────────
+        // ─── Personalities + insights (2.0.3) ─────────────────────────────────────
+        case 'personality': {
+            const { formatPersonalityList, findPersonality } = await import('../utils/personalities.js');
+            const sub = args[0]?.toLowerCase();
+            if (!sub) {
+                return { handled: true, response: formatPersonalityList(session.workspaceRoot) };
+            }
+            if (sub === 'off' || sub === 'none' || sub === 'clear') {
+                config.set('activePersonality', null);
+                return { handled: true, response: 'Personality cleared — agent uses default tone.' };
+            }
+            const p = findPersonality(sub, session.workspaceRoot);
+            if (!p) {
+                return { handled: true, response: `No personality named \`${sub}\`. Run \`/personality\` to see available.` };
+            }
+            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\`.`,
+            };
+        }
+        case 'insights': {
+            const { formatInsights } = await import('../utils/insights.js');
+            let days = 7;
+            for (let i = 0; i < args.length; i++) {
+                const a = args[i];
+                if (a === '--days' && args[i + 1]) {
+                    const n = parseInt(args[i + 1], 10);
+                    if (Number.isFinite(n))
+                        days = n;
+                }
+                else if (a.startsWith('--days=')) {
+                    const n = parseInt(a.slice('--days='.length), 10);
+                    if (Number.isFinite(n))
+                        days = n;
+                }
+            }
+            return { handled: true, response: formatInsights({ days }) };
+        }
         // ─── Plan mode (2.0.2) ────────────────────────────────────────────────────
         case 'plan': {
             // Identical contract to TUI /plan: generate a pre-execution plan,

package/dist/acp/server.js

@@ -55,6 +55,9 @@ const AVAILABLE_COMMANDS = [
     // Plan mode (2.0.2)
     { 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: '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' },
     { name: 'review', description: 'Run code review on project or specific files', input: { hint: '[file…]' } },

package/dist/config/index.d.ts

@@ -57,6 +57,13 @@ interface ConfigSchema {
         data_collection?: 'allow' | 'deny';
         require_parameters?: boolean;
     };
+    /**
+     * Active personality preset (`concise`, `senior-reviewer`, custom user
+     * personalities from .codeep/personalities/*.md, …). When set, the
+     * loader text is appended to every agent system prompt. See
+     * utils/personalities.ts.
+     */
+    activePersonality?: string | null;
 }
 export type { AgentMode };
 export type { LanguageCode };

package/dist/renderer/App.js

@@ -93,6 +93,8 @@ const COMMAND_DESCRIPTIONS = {
     'openrouter': 'Tune OpenRouter routing (preferred / ignore providers, fallbacks, privacy)',
     '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',
+    'insights': 'Activity summary over the last N days (default 7): runs, files, tools, projects',
 };
 import { helpCategories, keyboardShortcuts } from './components/Help.js';
 import { handleSettingsKey, SETTINGS } from './components/Settings.js';
@@ -234,6 +236,8 @@ export class App {
         'hooks', 'mcp', 'openrouter',
         // 2.0.2 — plan mode.
         'plan', 'go',
+        // 2.0.3 — personalities + insights.
+        'personality', 'insights',
         'c', 't', 'd', 'r', 'f', 'e', 'o', 'b', 'p',
     ];
     constructor(options) {
@@ -1889,7 +1893,8 @@ export class App {
         }
         // Footer
         const scrollInfo = allItems.length > maxVisible ? ` (${this.helpScrollIndex + 1}-${Math.min(this.helpScrollIndex + maxVisible, allItems.length)}/${allItems.length})` : '';
-        this.screen.writeLine(y, `↑↓ scroll • PgUp/PgDn fast scroll • Esc close${scrollInfo}`, fg.gray);
+        this.screen.writeLine(y++, `↑↓ scroll • PgUp/PgDn fast scroll • Esc close${scrollInfo}`, fg.gray);
+        this.screen.writeLine(y, 'Full guides → codeep.dev/docs    ·    /docs <command>  (e.g. /docs personality)', fg.cyan);
     }
     /**
      * Render inline autocomplete below status bar

package/dist/renderer/commands.js

@@ -216,6 +216,84 @@ export async function handleCommand(command, args, ctx) {
             runAgentTask(args.join(' '), true, ctx, () => null, () => { });
             break;
         }
+        case 'docs': {
+            // Open per-command web docs in the system browser. Lets the inline
+            // /help stay terse (single-line entries) while users who want the
+            // long story get one keystroke away from a real page.
+            const cmd = (args[0] ?? '').toLowerCase().replace(/^\//, '');
+            const KNOWN = {
+                personality: 'https://codeep.dev/docs/agent#personalities',
+                personalities: 'https://codeep.dev/docs/agent#personalities',
+                insights: 'https://codeep.dev/docs/agent#insights',
+                plan: 'https://codeep.dev/docs/agent#plan-mode',
+                go: 'https://codeep.dev/docs/agent#plan-mode',
+                mcp: 'https://codeep.dev/docs/mcp',
+                skills: 'https://codeep.dev/docs/skills',
+                checkpoint: 'https://codeep.dev/docs/commands#checkpoints',
+                rewind: 'https://codeep.dev/docs/commands#checkpoints',
+                hooks: 'https://codeep.dev/docs/commands#hooks',
+                commands: 'https://codeep.dev/docs/commands#custom-commands',
+                openrouter: 'https://codeep.dev/docs/providers#openrouter',
+                memory: 'https://codeep.dev/docs/commands#intelligence',
+                profile: 'https://codeep.dev/docs/commands#settings',
+                compact: 'https://codeep.dev/docs/commands#session',
+                cost: 'https://codeep.dev/docs/dashboard',
+            };
+            const url = cmd ? (KNOWN[cmd] ?? `https://codeep.dev/docs/commands?q=${encodeURIComponent(cmd)}`) : 'https://codeep.dev/docs';
+            try {
+                const { default: open } = await import('open');
+                await open(url);
+                ctx.app.notify(`Opening ${url}`);
+            }
+            catch {
+                ctx.app.notify(`Couldn't open browser. Visit: ${url}`);
+            }
+            break;
+        }
+        case 'insights': {
+            const { formatInsights } = await import('../utils/insights.js');
+            // Parse `--days N` (default 7). Accept both `--days 30` and `--days=30`.
+            let days = 7;
+            for (let i = 0; i < args.length; i++) {
+                const a = args[i];
+                if (a === '--days' && args[i + 1]) {
+                    const n = parseInt(args[i + 1], 10);
+                    if (Number.isFinite(n))
+                        days = n;
+                }
+                else if (a.startsWith('--days=')) {
+                    const n = parseInt(a.slice('--days='.length), 10);
+                    if (Number.isFinite(n))
+                        days = n;
+                }
+            }
+            ctx.app.addMessage({ role: 'system', content: formatInsights({ days }) });
+            break;
+        }
+        case 'personality': {
+            const { formatPersonalityList, findPersonality } = await import('../utils/personalities.js');
+            const sub = args[0]?.toLowerCase();
+            if (!sub) {
+                ctx.app.addMessage({ role: 'system', content: formatPersonalityList(ctx.projectPath) });
+                break;
+            }
+            if (sub === 'off' || sub === 'none' || sub === 'clear') {
+                config.set('activePersonality', null);
+                ctx.app.notify('Personality cleared — agent uses default tone.');
+                break;
+            }
+            const personality = findPersonality(sub, ctx.projectPath);
+            if (!personality) {
+                ctx.app.notify(`No personality named "${sub}". Run /personality to see available.`);
+                break;
+            }
+            config.set('activePersonality', personality.name);
+            ctx.app.addMessage({
+                role: 'system',
+                content: `Active personality: **${personality.displayName}** (\`${personality.name}\`, ${personality.scope})\n\n_${personality.description}_\n\nClear with \`/personality off\`.`,
+            });
+            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

package/dist/renderer/components/Help.js

@@ -123,6 +123,9 @@ export const helpCategories = [
             { key: '/profile save <name>', description: 'Save current provider+model as profile' },
             { key: '/profile list', description: 'List saved profiles' },
             { 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: '/insights [--days N]', description: 'Activity summary — runs, files, tools, projects over the last N days (default 7)' },
         ],
     },
     {

package/dist/utils/agent.js

@@ -253,6 +253,19 @@ export async function runAgent(prompt, projectContext, options = {}) {
     if (skillCatalogBlock) {
         systemPrompt += '\n\n' + skillCatalogBlock;
     }
+    // Active personality goes LAST — appended after skills / project rules /
+    // smart context so its tone overrides earlier conventions. Set via
+    // `/personality <name>`; empty when no personality is active.
+    try {
+        const { getActivePersonalityPrompt } = await import('./personalities.js');
+        const personalityPrompt = getActivePersonalityPrompt(projectContext.root);
+        if (personalityPrompt) {
+            systemPrompt += personalityPrompt;
+        }
+    }
+    catch {
+        // Personality loading must never block an agent run.
+    }
     // Initial user message with optional task plan
     let initialPrompt = prompt;
     if (taskPlan) {

package/dist/utils/insights.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `/insights` — agent activity summary over a configurable window.
+ *
+ * Source of truth: `~/.codeep/history/<id>.json`, one file per agent
+ * run, written by the agent loop. Schema (relevant fields):
+ *   { id, startTime, endTime, prompt, projectRoot, actions: [
+ *       { type: 'write' | 'read' | 'execute' | …, path?, command?, timestamp }
+ *     ]
+ *   }
+ *
+ * We deliberately don't read sessions/*.json here — sessions store
+ * chat history without tool-level detail, while history/ captures the
+ * exact actions which is what users want to see ("which file did I
+ * touch most this week?").
+ *
+ * Cost / token usage is per-process and lost across restarts (the
+ * token tracker is in-memory), so /insights reports actions and time
+ * but not historical dollar amounts. The current session's cost still
+ * shows in /cost.
+ */
+interface InsightsOptions {
+    /** Days to look back. Default 7. */
+    days?: number;
+}
+/**
+ * Format `/insights` output as Markdown. Returns a friendly empty-state
+ * message when there's no history in the window — we don't error.
+ */
+export declare function formatInsights(opts?: InsightsOptions): string;
+export {};

package/dist/utils/insights.js

@@ -0,0 +1,166 @@
+/**
+ * `/insights` — agent activity summary over a configurable window.
+ *
+ * Source of truth: `~/.codeep/history/<id>.json`, one file per agent
+ * run, written by the agent loop. Schema (relevant fields):
+ *   { id, startTime, endTime, prompt, projectRoot, actions: [
+ *       { type: 'write' | 'read' | 'execute' | …, path?, command?, timestamp }
+ *     ]
+ *   }
+ *
+ * We deliberately don't read sessions/*.json here — sessions store
+ * chat history without tool-level detail, while history/ captures the
+ * exact actions which is what users want to see ("which file did I
+ * touch most this week?").
+ *
+ * Cost / token usage is per-process and lost across restarts (the
+ * token tracker is in-memory), so /insights reports actions and time
+ * but not historical dollar amounts. The current session's cost still
+ * shows in /cost.
+ */
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join, basename } from 'path';
+import { homedir } from 'os';
+function loadHistoryRuns(sinceMs) {
+    const dir = join(homedir(), '.codeep', 'history');
+    if (!existsSync(dir))
+        return [];
+    let files;
+    try {
+        files = readdirSync(dir).filter((f) => f.endsWith('.json'));
+    }
+    catch {
+        return [];
+    }
+    const runs = [];
+    for (const file of files) {
+        try {
+            const raw = readFileSync(join(dir, file), 'utf8');
+            const run = JSON.parse(raw);
+            if (typeof run.startTime !== 'number')
+                continue;
+            if (run.startTime < sinceMs)
+                continue;
+            runs.push(run);
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    return runs.sort((a, b) => b.startTime - a.startTime);
+}
+function fmtDuration(ms) {
+    if (ms < 60_000)
+        return `${Math.round(ms / 1000)}s`;
+    if (ms < 3_600_000)
+        return `${Math.round(ms / 60_000)}m`;
+    const h = Math.floor(ms / 3_600_000);
+    const m = Math.round((ms % 3_600_000) / 60_000);
+    return m === 0 ? `${h}h` : `${h}h ${m}m`;
+}
+function relativeDayBucket(ts, now) {
+    const dayMs = 86_400_000;
+    const days = Math.floor((now - ts) / dayMs);
+    if (days === 0)
+        return 'today';
+    if (days === 1)
+        return 'yesterday';
+    if (days < 7)
+        return `${days}d ago`;
+    return new Date(ts).toISOString().slice(0, 10);
+}
+/**
+ * Format `/insights` output as Markdown. Returns a friendly empty-state
+ * message when there's no history in the window — we don't error.
+ */
+export function formatInsights(opts = {}) {
+    const days = Math.max(1, Math.min(365, opts.days ?? 7));
+    const now = Date.now();
+    const sinceMs = now - days * 86_400_000;
+    const runs = loadHistoryRuns(sinceMs);
+    const lines = [`## Activity — last ${days} day${days === 1 ? '' : 's'}`, ''];
+    if (runs.length === 0) {
+        lines.push(`_No agent runs in the last ${days} day${days === 1 ? '' : 's'}._`);
+        lines.push('');
+        lines.push('Run an agent task with `/agent <task>` (or just type a request when agent mode is on) — the activity here populates from `~/.codeep/history/`.');
+        return lines.join('\n');
+    }
+    // ── Headline metrics ──────────────────────────────────────────────────────
+    const totalRuns = runs.length;
+    const totalActions = runs.reduce((s, r) => s + (r.actions?.length ?? 0), 0);
+    const totalActiveMs = runs.reduce((s, r) => s + Math.max(0, (r.endTime ?? r.startTime) - r.startTime), 0);
+    const avgActions = (totalActions / totalRuns).toFixed(1);
+    const distinctDays = new Set(runs.map((r) => new Date(r.startTime).toISOString().slice(0, 10))).size;
+    lines.push(`**${totalRuns}** run${totalRuns === 1 ? '' : 's'}`
+        + `  ·  **${totalActions}** tool action${totalActions === 1 ? '' : 's'}`
+        + `  ·  **${fmtDuration(totalActiveMs)}** active`
+        + `  ·  **${distinctDays}**/${days} active day${distinctDays === 1 ? '' : 's'}`
+        + `  ·  avg **${avgActions}** action${avgActions === '1.0' ? '' : 's'}/run`);
+    // ── By project ────────────────────────────────────────────────────────────
+    const byProject = new Map();
+    for (const r of runs) {
+        const proj = r.projectRoot ? basename(r.projectRoot) : '(no project)';
+        const cur = byProject.get(proj) ?? { runs: 0, actions: 0, activeMs: 0 };
+        cur.runs++;
+        cur.actions += r.actions?.length ?? 0;
+        cur.activeMs += Math.max(0, (r.endTime ?? r.startTime) - r.startTime);
+        byProject.set(proj, cur);
+    }
+    const projects = [...byProject.entries()].sort((a, b) => b[1].activeMs - a[1].activeMs);
+    if (projects.length > 0) {
+        lines.push('', '### By project', '');
+        lines.push('| Project | Runs | Actions | Active time |');
+        lines.push('|---|---:|---:|---:|');
+        for (const [name, s] of projects.slice(0, 8)) {
+            lines.push(`| \`${name}\` | ${s.runs} | ${s.actions} | ${fmtDuration(s.activeMs)} |`);
+        }
+        if (projects.length > 8)
+            lines.push(`| _… and ${projects.length - 8} more_ | | | |`);
+    }
+    // ── Top tool types ────────────────────────────────────────────────────────
+    const byType = new Map();
+    for (const r of runs) {
+        for (const a of r.actions ?? []) {
+            byType.set(a.type, (byType.get(a.type) ?? 0) + 1);
+        }
+    }
+    const tools = [...byType.entries()].sort((a, b) => b[1] - a[1]);
+    if (tools.length > 0) {
+        lines.push('', '### Top tools', '');
+        for (const [name, count] of tools.slice(0, 8)) {
+            lines.push(`- \`${name}\` × **${count}**`);
+        }
+    }
+    // ── Top files touched ─────────────────────────────────────────────────────
+    const byPath = new Map();
+    for (const r of runs) {
+        for (const a of r.actions ?? []) {
+            if (a.path)
+                byPath.set(a.path, (byPath.get(a.path) ?? 0) + 1);
+        }
+    }
+    const files = [...byPath.entries()].sort((a, b) => b[1] - a[1]);
+    if (files.length > 0) {
+        lines.push('', '### Most-touched files', '');
+        for (const [path, count] of files.slice(0, 8)) {
+            // Trim home prefix for readability
+            const display = path.replace(homedir(), '~');
+            lines.push(`- \`${display}\` × **${count}**`);
+        }
+    }
+    // ── Recent runs ───────────────────────────────────────────────────────────
+    lines.push('', '### Recent runs', '');
+    for (const r of runs.slice(0, 10)) {
+        const when = relativeDayBucket(r.startTime, now);
+        const dur = fmtDuration(Math.max(0, (r.endTime ?? r.startTime) - r.startTime));
+        const proj = r.projectRoot ? basename(r.projectRoot) : '—';
+        const prompt = (r.prompt || '').replace(/\s+/g, ' ').trim();
+        const promptShort = prompt.length > 80 ? prompt.slice(0, 77) + '…' : prompt;
+        lines.push(`- _${when}_ · **${proj}** · ${dur} · ${promptShort}`);
+    }
+    // ── Session cost callout ──────────────────────────────────────────────────
+    // We only track tokens in-memory per process, so historical cost isn't
+    // available. Tell the user where to look for the current session.
+    lines.push('', "_For this session's cost + cache savings, run `/cost`._");
+    return lines.join('\n');
+}

package/dist/utils/personalities.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Personalities — pluggable system prompt addenda that shape how the
+ * agent communicates and what it prioritises.
+ *
+ * Storage:
+ *   - **Built-in**: hardcoded below (concise, verbose, security,
+ *     senior-reviewer, junior-mentor, ship-it).
+ *   - **Project**: `<workspace>/.codeep/personalities/<name>.md`
+ *   - **Global**:  `~/.codeep/personalities/<name>.md`
+ *
+ * Project shadows global shadows built-in, by name.
+ *
+ * File format (project / global):
+ *   ```
+ *   # Personality: Concise Reviewer
+ *   <free-form Markdown body — gets appended to system prompt verbatim>
+ *   ```
+ * (The first H1 line is parsed as the display name; everything else is
+ * the prompt body.)
+ *
+ * Activation:
+ *   - `config.activePersonality` holds the active name (or null/undefined
+ *     for default behaviour).
+ *   - `getActivePersonalityPrompt(workspaceRoot)` returns the prompt
+ *     addendum to inject into the agent's system prompt, or '' when no
+ *     personality is active.
+ *   - Persists across sessions until cleared with `/personality off`.
+ */
+export type PersonalityScope = 'builtin' | 'project' | 'global';
+export interface Personality {
+    /** Slug (filename without .md, or built-in id). Lowercase, hyphens. */
+    name: string;
+    /** Human display label shown in `/personality` list. */
+    displayName: string;
+    /** One-line description for the list view. */
+    description: string;
+    /** Markdown body appended to the system prompt when active. */
+    prompt: string;
+    scope: PersonalityScope;
+}
+export declare function loadAllPersonalities(workspaceRoot?: string): Personality[];
+export declare function findPersonality(name: string, workspaceRoot?: string): Personality | null;
+/**
+ * Returns the prompt addendum for the currently active personality, or
+ * '' when none is set. Called from agent.ts after the base system prompt
+ * is composed — appended last so personality overrides apply even if
+ * project rules conflict.
+ */
+export declare function getActivePersonalityPrompt(workspaceRoot?: string): string;
+export declare function formatPersonalityList(workspaceRoot?: string): string;

package/dist/utils/personalities.js

@@ -0,0 +1,226 @@
+/**
+ * Personalities — pluggable system prompt addenda that shape how the
+ * agent communicates and what it prioritises.
+ *
+ * Storage:
+ *   - **Built-in**: hardcoded below (concise, verbose, security,
+ *     senior-reviewer, junior-mentor, ship-it).
+ *   - **Project**: `<workspace>/.codeep/personalities/<name>.md`
+ *   - **Global**:  `~/.codeep/personalities/<name>.md`
+ *
+ * Project shadows global shadows built-in, by name.
+ *
+ * File format (project / global):
+ *   ```
+ *   # Personality: Concise Reviewer
+ *   <free-form Markdown body — gets appended to system prompt verbatim>
+ *   ```
+ * (The first H1 line is parsed as the display name; everything else is
+ * the prompt body.)
+ *
+ * Activation:
+ *   - `config.activePersonality` holds the active name (or null/undefined
+ *     for default behaviour).
+ *   - `getActivePersonalityPrompt(workspaceRoot)` returns the prompt
+ *     addendum to inject into the agent's system prompt, or '' when no
+ *     personality is active.
+ *   - Persists across sessions until cleared with `/personality off`.
+ */
+import { readFileSync, readdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { config } from '../config/index.js';
+const BUILTIN = [
+    {
+        name: 'concise',
+        displayName: 'Concise',
+        description: 'Short answers. No preamble. No filler. Get in, get out.',
+        scope: 'builtin',
+        prompt: `
+
+## Personality: Concise
+
+Keep responses tight:
+- Skip preamble ("Great question!", "Let me help…") — go straight to substance.
+- Use bullet points over paragraphs for lists of 3+ items.
+- One code block per answer when possible; no commentary around obvious code.
+- Prefer "Done." over "I've successfully completed the task by…"
+- No emojis unless the user explicitly uses them first.`,
+    },
+    {
+        name: 'verbose',
+        displayName: 'Verbose',
+        description: 'Detailed explanations with rationale, alternatives considered, and caveats.',
+        scope: 'builtin',
+        prompt: `
+
+## Personality: Verbose
+
+Take time to explain:
+- For every non-trivial change, lay out: what / why / alternatives I considered / why I chose this one.
+- Cite line numbers and file paths so the user can audit.
+- When reading code, summarise what the surrounding context does before acting — this catches misunderstandings early.
+- End complex tasks with a "what to verify" checklist for the user.`,
+    },
+    {
+        name: 'security',
+        displayName: 'Security-paranoid',
+        description: 'Flags every input as untrusted, second-guesses every API call, prefers defensive code.',
+        scope: 'builtin',
+        prompt: `
+
+## Personality: Security-paranoid
+
+Treat every input as hostile until proven otherwise:
+- For any code that touches user input, env vars, file paths, or network: enumerate the attack surface in a short comment block above the code.
+- Prefer allowlists over blocklists. Prefer parameterised queries / escape-on-output to ad-hoc sanitisation.
+- Flag every secret/key reference and ensure it's read from env or secret manager — never inline.
+- When suggesting dependencies, prefer audited ones (cite stars / last-publish date) and note known CVEs if any.
+- After implementing, list 2-3 concrete attack scenarios you considered (e.g. "what if input contains '../'?") and how the code handles them.`,
+    },
+    {
+        name: 'senior-reviewer',
+        displayName: 'Senior reviewer',
+        description: 'Strong opinions on architecture, naming, abstraction boundaries. Pushes back on shortcuts.',
+        scope: 'builtin',
+        prompt: `
+
+## Personality: Senior Reviewer
+
+Critique like a staff engineer reviewing a PR from a colleague:
+- If the proposed approach has a cleaner alternative, propose it first — even if the user's framing pushed toward the messier one.
+- Name things with the team in mind. Reject lazy names (handler, util, manager) and propose specific ones.
+- Watch for premature abstraction (one-call helpers) and missing abstractions (3rd copy of the same 5 lines).
+- Push back on "just for now" hacks unless the user explicitly says it's a throwaway.
+- Mention what's NOT tested when adding new code, and suggest the test cases that'd catch likely regressions.`,
+    },
+    {
+        name: 'junior-mentor',
+        displayName: 'Junior mentor',
+        description: 'Explains concepts as you go, links to docs, suggests what to learn next.',
+        scope: 'builtin',
+        prompt: `
+
+## Personality: Junior Mentor
+
+The user is learning — meet them where they are:
+- Before introducing a new concept, give a 1-2 sentence "why this exists" context.
+- Use analogies for abstract topics (closures = "a backpack the function carries"). Keep them grounded, not fancy.
+- Link to canonical docs (MDN, language reference, official tutorial) rather than blog posts.
+- After completing a task, suggest 1 thing to read or 1 small follow-up exercise that reinforces the concept just used.
+- Resist showing off. Don't introduce ES2024 destructuring spread tricks when a plain for-loop teaches the lesson better.`,
+    },
+    {
+        name: 'ship-it',
+        displayName: 'Ship it',
+        description: 'Optimise for speed-to-merge. No bikeshedding. "Done is better than perfect" mode.',
+        scope: 'builtin',
+        prompt: `
+
+## Personality: Ship It
+
+The user wants this merged today:
+- Pick the first reasonable approach. Don't enumerate three alternatives — commit to one.
+- Inline TODO comments are fine for cleanup-later items. Don't refactor adjacent code.
+- Test the happy path. Edge cases can wait for follow-up unless they're security-relevant.
+- Suggest minimum-viable solution, not robust-for-all-cases. The user can iterate.
+- If the user asks "should we also…", default to "no, ship this first, that's a separate PR".`,
+    },
+];
+/** Load custom personalities from a `.codeep/personalities/` directory. */
+function loadFromDir(dir, scope) {
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return [];
+    }
+    for (const entry of entries) {
+        if (!entry.endsWith('.md'))
+            continue;
+        const name = entry.slice(0, -3).toLowerCase();
+        if (!/^[a-z0-9][a-z0-9-]*$/.test(name))
+            continue; // skip weirdly-named files
+        try {
+            const raw = readFileSync(join(dir, entry), 'utf8');
+            if (raw.length > 64 * 1024)
+                continue; // cap at 64 KB
+            // First H1 → displayName; rest → prompt.
+            const h1 = raw.match(/^#\s+(?:Personality:\s+)?(.+)$/m);
+            const displayName = h1?.[1].trim() ?? name;
+            const body = h1 ? raw.slice(raw.indexOf('\n', raw.indexOf(h1[0])) + 1).trimStart() : raw;
+            // First paragraph (or line) → description (cap 200 chars).
+            const firstPara = body.split(/\n\s*\n/)[0]?.replace(/\s+/g, ' ').trim() ?? '';
+            const description = firstPara.length > 200 ? firstPara.slice(0, 197) + '…' : firstPara;
+            out.push({
+                name,
+                displayName,
+                description: description || `Custom personality from ${entry}`,
+                prompt: '\n\n## Personality: ' + displayName + '\n\n' + body,
+                scope,
+            });
+        }
+        catch {
+            // Skip broken files — never crash personality loading.
+        }
+    }
+    return out;
+}
+export function loadAllPersonalities(workspaceRoot) {
+    const project = workspaceRoot
+        ? loadFromDir(join(workspaceRoot, '.codeep', 'personalities'), 'project')
+        : [];
+    const global = loadFromDir(join(homedir(), '.codeep', 'personalities'), 'global');
+    // Merge with scope priority: project > global > builtin.
+    const byName = new Map();
+    for (const p of BUILTIN)
+        byName.set(p.name, p);
+    for (const p of global)
+        byName.set(p.name, p);
+    for (const p of project)
+        byName.set(p.name, p);
+    return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
+}
+export function findPersonality(name, workspaceRoot) {
+    const lower = name.toLowerCase();
+    return loadAllPersonalities(workspaceRoot).find((p) => p.name === lower) ?? null;
+}
+/**
+ * Returns the prompt addendum for the currently active personality, or
+ * '' when none is set. Called from agent.ts after the base system prompt
+ * is composed — appended last so personality overrides apply even if
+ * project rules conflict.
+ */
+export function getActivePersonalityPrompt(workspaceRoot) {
+    const name = config.get('activePersonality');
+    if (!name)
+        return '';
+    const p = findPersonality(name, workspaceRoot);
+    return p?.prompt ?? '';
+}
+export function formatPersonalityList(workspaceRoot) {
+    const list = loadAllPersonalities(workspaceRoot);
+    const active = config.get('activePersonality');
+    const lines = ['## Personalities', ''];
+    if (active) {
+        lines.push(`**Active:** \`${active}\` — switch with \`/personality <name>\` or clear with \`/personality off\`.`);
+    }
+    else {
+        lines.push('**Active:** _(none — agent uses default tone)_');
+    }
+    lines.push('');
+    lines.push('| Name | Scope | Description |');
+    lines.push('|---|---|---|');
+    for (const p of list) {
+        const tag = p.scope === 'builtin' ? 'built-in' : p.scope;
+        const marker = active === p.name ? ' ✓' : '';
+        lines.push(`| \`${p.name}\`${marker} | ${tag} | ${p.description} |`);
+    }
+    lines.push('');
+    lines.push('Drop a `<name>.md` file into `.codeep/personalities/` (project) or `~/.codeep/personalities/` (global) to add your own — first `#` line becomes the display name, body becomes the prompt addendum.');
+    return lines.join('\n');
+}

package/package.json

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