@auxiora/personality 1.0.0

package/src/modes/__tests__/mode-detector.test.ts

@@ -0,0 +1,149 @@
+import { describe, it, expect } from 'vitest';
+import { ModeDetector } from '../mode-detector.js';
+import type { ModeId, ModeTemplate, SessionModeState } from '../types.js';
+
+function makeMode(id: ModeId, signals: Array<{ phrase: string; weight: number }>): ModeTemplate {
+  return { id, name: id, description: `${id} mode`, promptContent: `# ${id}`, signals };
+}
+
+function buildModes(): Map<ModeId, ModeTemplate> {
+  const modes = new Map<ModeId, ModeTemplate>();
+  modes.set('operator', makeMode('operator', [
+    { phrase: 'run', weight: 0.8 }, { phrase: 'execute', weight: 0.8 },
+    { phrase: 'deploy', weight: 0.8 }, { phrase: 'status', weight: 0.6 },
+  ]));
+  modes.set('analyst', makeMode('analyst', [
+    { phrase: 'analyze', weight: 0.8 }, { phrase: 'investigate', weight: 0.8 },
+    { phrase: "what's the risk", weight: 0.9 }, { phrase: 'compare', weight: 0.7 },
+  ]));
+  modes.set('advisor', makeMode('advisor', [
+    { phrase: 'should i', weight: 0.8 }, { phrase: 'help me decide', weight: 0.9 },
+    { phrase: 'trade-offs', weight: 0.8 }, { phrase: 'options', weight: 0.6 },
+  ]));
+  modes.set('writer', makeMode('writer', [
+    { phrase: 'write', weight: 0.7 }, { phrase: 'draft', weight: 0.8 },
+    { phrase: 'blog post', weight: 0.9 }, { phrase: 'email', weight: 0.7 },
+  ]));
+  modes.set('socratic', makeMode('socratic', [
+    { phrase: 'challenge me', weight: 0.9 }, { phrase: 'red team', weight: 0.9 },
+    { phrase: 'what am i missing', weight: 0.8 }, { phrase: 'poke holes', weight: 0.8 },
+  ]));
+  modes.set('legal', makeMode('legal', [
+    { phrase: 'compliance', weight: 0.9 }, { phrase: 'regulation', weight: 0.8 },
+    { phrase: 'contract', weight: 0.8 }, { phrase: 'legal', weight: 0.8 },
+  ]));
+  modes.set('roast', makeMode('roast', [
+    { phrase: 'roast', weight: 0.9 }, { phrase: "don't sugarcoat", weight: 0.8 },
+    { phrase: 'give it to me straight', weight: 0.8 },
+  ]));
+  modes.set('companion', makeMode('companion', [
+    { phrase: 'how are you', weight: 0.4 }, { phrase: 'just chatting', weight: 0.6 },
+    { phrase: 'feeling', weight: 0.5 },
+  ]));
+  return modes;
+}
+
+describe('ModeDetector', () => {
+  const modes = buildModes();
+  const detector = new ModeDetector(modes);
+
+  it('should detect operator mode from "run" signals', () => {
+    const result = detector.detect('run the test suite and deploy');
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('operator');
+  });
+
+  it('should detect analyst mode from analysis signals', () => {
+    const result = detector.detect("analyze this data and what's the risk here");
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('analyst');
+  });
+
+  it('should detect advisor mode from decision signals', () => {
+    const result = detector.detect('should i go with option A? help me decide');
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('advisor');
+  });
+
+  it('should detect writer mode from writing signals', () => {
+    const result = detector.detect('draft a blog post about TypeScript');
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('writer');
+  });
+
+  it('should detect socratic mode from challenge signals', () => {
+    const result = detector.detect('challenge me on this. red team my plan');
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('socratic');
+  });
+
+  it('should detect legal mode from compliance signals', () => {
+    const result = detector.detect('check this contract for compliance issues');
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('legal');
+  });
+
+  it('should detect roast mode from roast signals', () => {
+    const result = detector.detect("roast my code, don't sugarcoat it");
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('roast');
+  });
+
+  it('should detect companion mode from casual signals', () => {
+    const result = detector.detect("how are you feeling today? just chatting");
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('companion');
+  });
+
+  it('should return null for empty messages', () => {
+    expect(detector.detect('')).toBeNull();
+  });
+
+  it('should return null for very short messages', () => {
+    expect(detector.detect('hi')).toBeNull();
+  });
+
+  it('should return null when no signals match', () => {
+    expect(detector.detect('tell me a random fact about penguins')).toBeNull();
+  });
+
+  it('should score higher with multiple matching keywords', () => {
+    const single = detector.detect('run this');
+    const multiple = detector.detect('run and execute, then deploy');
+    expect(single).not.toBeNull();
+    expect(multiple).not.toBeNull();
+    // Multiple matches should still resolve to operator
+    expect(multiple!.mode).toBe('operator');
+  });
+
+  it('should apply hysteresis bias to current mode', () => {
+    // When current mode is "operator" and message has weak operator signal
+    const state: SessionModeState = { activeMode: 'operator', autoDetected: true };
+    const result = detector.detect('check the status', { currentState: state });
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('operator');
+  });
+
+  it('should apply task type boosting for code messages', () => {
+    // "execute" is a weak operator signal; "code" task type should boost it
+    const withBoost = detector.detect('run and execute this', { taskType: 'code' });
+    expect(withBoost).not.toBeNull();
+    expect(withBoost!.mode).toBe('operator');
+  });
+
+  it('should return candidates sorted by score', () => {
+    const result = detector.detect('analyze the status and run diagnostics');
+    expect(result).not.toBeNull();
+    expect(result!.candidates.length).toBeGreaterThan(0);
+    // Candidates should be sorted descending by score
+    for (let i = 1; i < result!.candidates.length; i++) {
+      expect(result!.candidates[i - 1].score).toBeGreaterThanOrEqual(result!.candidates[i].score);
+    }
+  });
+
+  it('should handle case-insensitive matching', () => {
+    const result = detector.detect('ANALYZE this data');
+    expect(result).not.toBeNull();
+    expect(result!.mode).toBe('analyst');
+  });
+});

package/src/modes/__tests__/mode-loader.test.ts

@@ -0,0 +1,143 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { ModeLoader } from '../mode-loader.js';
+
+describe('ModeLoader', () => {
+  let tmpDir: string;
+  let builtInDir: string;
+  let userDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'mode-loader-test-'));
+    builtInDir = path.join(tmpDir, 'built-in');
+    userDir = path.join(tmpDir, 'user');
+    await fs.mkdir(builtInDir, { recursive: true });
+    await fs.mkdir(userDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  it('should load built-in mode files', async () => {
+    await fs.writeFile(
+      path.join(builtInDir, 'operator.md'),
+      `<!-- mode: operator\n name: Operator\n description: Fast execution\n signals: run:0.8, execute:0.7 -->\n# Operator mode content`,
+    );
+    await fs.writeFile(
+      path.join(builtInDir, 'analyst.md'),
+      `<!-- mode: analyst\n name: Analyst\n description: Deep analysis\n signals: analyze:0.8 -->\n# Analyst mode content`,
+    );
+
+    const loader = new ModeLoader(builtInDir, userDir);
+    const modes = await loader.loadAll();
+
+    expect(modes.size).toBe(2);
+    expect(modes.get('operator')).toBeDefined();
+    expect(modes.get('analyst')).toBeDefined();
+  });
+
+  it('should parse metadata correctly', async () => {
+    await fs.writeFile(
+      path.join(builtInDir, 'writer.md'),
+      `<!-- mode: writer\n name: Writer\n description: Creative writing\n signals: write:0.7, draft:0.8, blog post:0.9 -->\n# Writer mode\nBe creative.`,
+    );
+
+    const loader = new ModeLoader(builtInDir, userDir);
+    await loader.loadAll();
+    const mode = loader.get('writer');
+
+    expect(mode).toBeDefined();
+    expect(mode!.name).toBe('Writer');
+    expect(mode!.description).toBe('Creative writing');
+    expect(mode!.signals).toHaveLength(3);
+    expect(mode!.signals[0]).toEqual({ phrase: 'write', weight: 0.7 });
+    expect(mode!.signals[1]).toEqual({ phrase: 'draft', weight: 0.8 });
+    expect(mode!.signals[2]).toEqual({ phrase: 'blog post', weight: 0.9 });
+    expect(mode!.promptContent).toContain('# Writer mode');
+    expect(mode!.promptContent).toContain('Be creative.');
+  });
+
+  it('should return empty map when directory does not exist', async () => {
+    const loader = new ModeLoader('/nonexistent/path', '/also/nonexistent');
+    const modes = await loader.loadAll();
+    expect(modes.size).toBe(0);
+  });
+
+  it('should skip files without valid metadata', async () => {
+    // File with no HTML comment header
+    await fs.writeFile(
+      path.join(builtInDir, 'operator.md'),
+      `# Just some markdown\nNo metadata here.`,
+    );
+
+    const loader = new ModeLoader(builtInDir, userDir);
+    const modes = await loader.loadAll();
+    expect(modes.size).toBe(0);
+  });
+
+  it('should skip non-.md files', async () => {
+    await fs.writeFile(path.join(builtInDir, 'readme.txt'), 'not a mode');
+    await fs.writeFile(
+      path.join(builtInDir, 'operator.md'),
+      `<!-- mode: operator\n name: Operator\n description: test\n signals: run:0.8 -->\ncontent`,
+    );
+
+    const loader = new ModeLoader(builtInDir, userDir);
+    const modes = await loader.loadAll();
+    expect(modes.size).toBe(1);
+  });
+
+  it('should skip files with unknown mode IDs', async () => {
+    await fs.writeFile(
+      path.join(builtInDir, 'custom-mode.md'),
+      `<!-- mode: custom-mode\n name: Custom\n description: test\n signals: foo:0.8 -->\ncontent`,
+    );
+
+    const loader = new ModeLoader(builtInDir, userDir);
+    const modes = await loader.loadAll();
+    expect(modes.size).toBe(0);
+  });
+
+  it('should allow user modes to override built-in modes', async () => {
+    await fs.writeFile(
+      path.join(builtInDir, 'operator.md'),
+      `<!-- mode: operator\n name: Operator\n description: Built-in operator\n signals: run:0.8 -->\nBuilt-in content`,
+    );
+    await fs.writeFile(
+      path.join(userDir, 'operator.md'),
+      `<!-- mode: operator\n name: My Operator\n description: Custom operator\n signals: run:0.9, go:0.7 -->\nCustom content`,
+    );
+
+    const loader = new ModeLoader(builtInDir, userDir);
+    await loader.loadAll();
+    const mode = loader.get('operator');
+
+    expect(mode).toBeDefined();
+    expect(mode!.name).toBe('My Operator');
+    expect(mode!.description).toBe('Custom operator');
+    expect(mode!.promptContent).toBe('Custom content');
+  });
+
+  it('should reload modes', async () => {
+    await fs.writeFile(
+      path.join(builtInDir, 'operator.md'),
+      `<!-- mode: operator\n name: Operator\n description: v1\n signals: run:0.8 -->\nv1`,
+    );
+
+    const loader = new ModeLoader(builtInDir, userDir);
+    await loader.loadAll();
+    expect(loader.get('operator')!.description).toBe('v1');
+
+    // Modify file
+    await fs.writeFile(
+      path.join(builtInDir, 'operator.md'),
+      `<!-- mode: operator\n name: Operator\n description: v2\n signals: run:0.8 -->\nv2`,
+    );
+
+    await loader.reload();
+    expect(loader.get('operator')!.description).toBe('v2');
+  });
+});

package/src/modes/__tests__/prompt-assembler.test.ts

@@ -0,0 +1,291 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { PromptAssembler } from '../prompt-assembler.js';
+import { ModeLoader } from '../mode-loader.js';
+import type { AgentIdentity } from '@auxiora/config';
+import type { SessionModeState, UserPreferences } from '../types.js';
+import { DEFAULT_PREFERENCES } from '../types.js';
+import { SecurityFloor } from '../../security-floor.js';
+import type { EscalationState } from '../../escalation.js';
+
+// Mock @auxiora/core path getters to use temp dirs
+let workspaceDir: string;
+vi.mock('@auxiora/core', () => ({
+  getSoulPath: () => path.join(workspaceDir, 'SOUL.md'),
+  getAgentsPath: () => path.join(workspaceDir, 'AGENTS.md'),
+  getIdentityPath: () => path.join(workspaceDir, 'IDENTITY.md'),
+  getUserPath: () => path.join(workspaceDir, 'USER.md'),
+}));
+
+const defaultAgent: AgentIdentity = {
+  name: 'TestBot',
+  pronouns: 'they/them',
+  personality: 'professional',
+  tone: { warmth: 0.6, directness: 0.5, humor: 0.3, formality: 0.5 },
+  expertise: [],
+  errorStyle: 'professional',
+  catchphrases: {},
+  boundaries: { neverJokeAbout: [], neverAdviseOn: [] },
+};
+
+describe('PromptAssembler', () => {
+  let tmpDir: string;
+  let modesDir: string;
+
+  beforeEach(async () => {
+    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), 'prompt-assembler-test-'));
+    workspaceDir = path.join(tmpDir, 'workspace');
+    modesDir = path.join(tmpDir, 'modes');
+    await fs.mkdir(workspaceDir, { recursive: true });
+    await fs.mkdir(modesDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(tmpDir, { recursive: true, force: true });
+  });
+
+  async function createAssembler(modeFiles?: Record<string, string>) {
+    if (modeFiles) {
+      for (const [name, content] of Object.entries(modeFiles)) {
+        await fs.writeFile(path.join(modesDir, name), content);
+      }
+    }
+    const loader = new ModeLoader(modesDir, path.join(tmpDir, 'user-modes'));
+    await loader.loadAll();
+    return new PromptAssembler(defaultAgent, loader);
+  }
+
+  it('should build base prompt with identity preamble when SOUL.md exists', async () => {
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul');
+    const assembler = await createAssembler();
+    const base = await assembler.buildBase();
+    expect(base).toContain('# Agent Identity');
+    expect(base).toContain('TestBot');
+    expect(base).toContain('they/them');
+  });
+
+  it('should include SOUL.md when present', async () => {
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# My Soul\nI am helpful.');
+    const assembler = await createAssembler();
+    const base = await assembler.buildBase();
+    expect(base).toContain('# My Soul');
+    expect(base).toContain('I am helpful.');
+  });
+
+  it('should handle missing optional files gracefully', async () => {
+    // No SOUL.md, AGENTS.md, IDENTITY.md, or USER.md
+    const assembler = await createAssembler();
+    const base = await assembler.buildBase();
+    // Should fall through to default prompt
+    expect(base).toContain('TestBot');
+    expect(base).toContain('helpful AI assistant');
+  });
+
+  it('should include all context files when present', async () => {
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul content');
+    await fs.writeFile(path.join(workspaceDir, 'AGENTS.md'), '# Agent definitions');
+    await fs.writeFile(path.join(workspaceDir, 'IDENTITY.md'), '# Custom identity');
+    await fs.writeFile(path.join(workspaceDir, 'USER.md'), 'User profile info');
+
+    const assembler = await createAssembler();
+    const base = await assembler.buildBase();
+
+    expect(base).toContain('# Soul content');
+    expect(base).toContain('# Agent definitions');
+    expect(base).toContain('# Custom identity');
+    expect(base).toContain('About the User');
+    expect(base).toContain('User profile info');
+  });
+
+  it('should inject mode instructions when mode is active', async () => {
+    const assembler = await createAssembler({
+      'operator.md': `<!-- mode: operator\n name: Operator\n description: Fast exec\n signals: run:0.8 -->\nBe fast and direct.`,
+    });
+    await assembler.buildBase();
+
+    const state: SessionModeState = { activeMode: 'operator', autoDetected: false };
+    const enriched = assembler.enrichForMessage(state, null);
+
+    expect(enriched).toContain('Active Mode: Operator');
+    expect(enriched).toContain('Be fast and direct.');
+  });
+
+  it('should not inject mode when mode is "auto"', async () => {
+    const assembler = await createAssembler({
+      'operator.md': `<!-- mode: operator\n name: Operator\n description: test\n signals: run:0.8 -->\nOperator content`,
+    });
+    await assembler.buildBase();
+
+    const state: SessionModeState = { activeMode: 'auto', autoDetected: false };
+    const enriched = assembler.enrichForMessage(state, null);
+
+    expect(enriched).not.toContain('Active Mode');
+  });
+
+  it('should not inject mode when mode is "off"', async () => {
+    const assembler = await createAssembler({
+      'operator.md': `<!-- mode: operator\n name: Operator\n description: test\n signals: run:0.8 -->\nOperator content`,
+    });
+    await assembler.buildBase();
+
+    const state: SessionModeState = { activeMode: 'off', autoDetected: false };
+    const enriched = assembler.enrichForMessage(state, null);
+
+    expect(enriched).not.toContain('Active Mode');
+  });
+
+  it('should append memory section to enriched prompt', async () => {
+    const assembler = await createAssembler();
+    await assembler.buildBase();
+
+    const state: SessionModeState = { activeMode: 'auto', autoDetected: false };
+    const enriched = assembler.enrichForMessage(state, '\n\n## Memories\nUser likes TypeScript.');
+
+    expect(enriched).toContain('## Memories');
+    expect(enriched).toContain('User likes TypeScript.');
+  });
+
+  it('should render extreme preference values', async () => {
+    const assembler = await createAssembler();
+    const extreme: UserPreferences = {
+      verbosity: 0.0,
+      formality: 1.0,
+      proactiveness: 0.0,
+      riskTolerance: 1.0,
+      humor: 0.0,
+      feedbackStyle: 'sandwich',
+      expertiseAssumption: 'expert',
+    };
+
+    const rendered = assembler.renderPreferences(extreme);
+    expect(rendered).toContain('concise');
+    expect(rendered).toContain('formal');
+    expect(rendered).toContain('Only answer what is directly asked');
+    expect(rendered).toContain('bold');
+    expect(rendered).toContain('serious');
+    expect(rendered).toContain('sandwich');
+    expect(rendered).toContain('deep technical knowledge');
+  });
+
+  it('should not render preferences at default values', async () => {
+    const assembler = await createAssembler();
+    const rendered = assembler.renderPreferences(DEFAULT_PREFERENCES);
+    // At 0.5 values, no extreme language should appear
+    expect(rendered).not.toContain('concise');
+    expect(rendered).not.toContain('thorough');
+    expect(rendered).not.toContain('casual');
+    expect(rendered).not.toContain('formal');
+  });
+
+  it('should produce backward-compatible prompt when no modes active', async () => {
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul');
+    const assembler = await createAssembler();
+    const base = await assembler.buildBase();
+
+    // With no mode state, enrichment should just be base + memory
+    const enriched = assembler.enrichForMessage(undefined, '\n\nmemory');
+    expect(enriched).toBe(base + '\n\nmemory');
+  });
+
+  // --- Security context and escalation tests ---
+
+  it('should produce security floor section without mode instructions', async () => {
+    const assembler = await createAssembler({
+      'operator.md': `<!-- mode: operator\n name: Operator\n description: test\n signals: run:0.8 -->\nOperator content`,
+    });
+    await assembler.buildBase();
+
+    const sf = new SecurityFloor();
+    const ctx = sf.detectSecurityContext({ userMessage: 'rotate my API key' });
+    const enriched = assembler.enrichForSecurityContext(ctx, sf, null);
+
+    expect(enriched).toContain('Security Floor Active');
+    expect(enriched).not.toContain('Active Mode');
+    expect(enriched).not.toContain('User Preferences');
+  });
+
+  it('should include memories in security context prompt', async () => {
+    const assembler = await createAssembler();
+    await assembler.buildBase();
+
+    const sf = new SecurityFloor();
+    const ctx = sf.detectSecurityContext({ userMessage: 'revoke access' });
+    const enriched = assembler.enrichForSecurityContext(ctx, sf, '\n\n## Memories\nUser prefers verbose.');
+
+    expect(enriched).toContain('Security Floor Active');
+    expect(enriched).toContain('## Memories');
+    expect(enriched).toContain('User prefers verbose.');
+  });
+
+  it('should dampen tone for caution escalation', async () => {
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul');
+    const assembler = await createAssembler();
+    await assembler.buildBase();
+
+    const escalation: EscalationState = { level: 'caution', lastEvent: 'uncertainty' };
+    const enriched = assembler.enrichForMessage(undefined, null, undefined, escalation);
+
+    // Humor should be halved: 0.3 * 0.5 = 0.15
+    expect(enriched).toContain('Humor: 0.15/1.0');
+  });
+
+  it('should zero humor for serious escalation', async () => {
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul');
+    const assembler = await createAssembler();
+    await assembler.buildBase();
+
+    const escalation: EscalationState = { level: 'serious', lastEvent: 'access_failure' };
+    const enriched = assembler.enrichForMessage(undefined, null, undefined, escalation);
+
+    expect(enriched).toContain('Humor: 0/1.0');
+    expect(enriched).toContain('Directness: 0.6/1.0'); // raised from 0.5
+  });
+
+  it('should not dampen tone without escalation param (backward compat)', async () => {
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul');
+    const assembler = await createAssembler();
+    const base = await assembler.buildBase();
+
+    // Without escalation, enrichment should use original base
+    const enriched = assembler.enrichForMessage(undefined, null);
+    expect(enriched).toBe(base);
+  });
+
+  // --- Vibe and custom instructions tests ---
+
+  it('includes vibe in identity preamble when set', async () => {
+    const agentWithVibe: AgentIdentity = {
+      ...defaultAgent,
+      vibe: 'warm, witty, slightly sarcastic',
+    };
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul');
+    const loader = new ModeLoader(modesDir, path.join(tmpDir, 'user-modes'));
+    await loader.loadAll();
+    const assembler = new PromptAssembler(agentWithVibe, loader);
+    const base = await assembler.buildBase();
+    expect(base).toContain('Vibe: warm, witty, slightly sarcastic');
+  });
+
+  it('includes custom instructions after SOUL.md', async () => {
+    const agentWithInstructions: AgentIdentity = {
+      ...defaultAgent,
+      customInstructions: 'Always respond in haiku format when possible.',
+    };
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul');
+    const loader = new ModeLoader(modesDir, path.join(tmpDir, 'user-modes'));
+    await loader.loadAll();
+    const assembler = new PromptAssembler(agentWithInstructions, loader);
+    const base = await assembler.buildBase();
+    expect(base).toContain('## Custom Instructions');
+    expect(base).toContain('Always respond in haiku format when possible.');
+  });
+
+  it('omits vibe line when vibe is undefined', async () => {
+    await fs.writeFile(path.join(workspaceDir, 'SOUL.md'), '# Soul');
+    const assembler = await createAssembler();
+    const base = await assembler.buildBase();
+    expect(base).not.toContain('Vibe:');
+  });
+});

package/src/modes/mode-detector.ts

@@ -0,0 +1,84 @@
+import type { ModeId, ModeTemplate, ModeDetectionResult, SessionModeState } from './types.js';
+
+const TASK_TYPE_BOOSTS: Record<string, Partial<Record<ModeId, number>>> = {
+  code: { operator: 0.15 },
+  reasoning: { analyst: 0.1, socratic: 0.1 },
+  creative: { writer: 0.15 },
+  fast: { operator: 0.1 },
+};
+
+const HYSTERESIS_BONUS = 0.05;
+
+export class ModeDetector {
+  private modes: Map<ModeId, ModeTemplate>;
+
+  constructor(modes: Map<ModeId, ModeTemplate>) {
+    this.modes = modes;
+  }
+
+  detect(
+    message: string,
+    context?: { taskType?: string; currentState?: SessionModeState },
+  ): ModeDetectionResult | null {
+    if (!message || message.length < 3) return null;
+
+    const lowerMessage = message.toLowerCase();
+    const scores = new Map<ModeId, number>();
+
+    for (const [id, mode] of this.modes) {
+      let score = 0;
+      for (const signal of mode.signals) {
+        if (lowerMessage.includes(signal.phrase)) {
+          score += signal.weight;
+        }
+      }
+      if (score > 0) {
+        scores.set(id, score);
+      }
+    }
+
+    if (scores.size === 0) return null;
+
+    // Apply task-type boosts
+    if (context?.taskType) {
+      const boosts = TASK_TYPE_BOOSTS[context.taskType];
+      if (boosts) {
+        for (const [modeId, boost] of Object.entries(boosts)) {
+          const current = scores.get(modeId as ModeId) ?? 0;
+          if (current > 0) {
+            scores.set(modeId as ModeId, current + boost);
+          }
+        }
+      }
+    }
+
+    // Apply hysteresis for current mode
+    if (context?.currentState?.activeMode && context.currentState.activeMode !== 'auto' && context.currentState.activeMode !== 'off') {
+      const currentMode = context.currentState.activeMode as ModeId;
+      const current = scores.get(currentMode);
+      if (current !== undefined) {
+        scores.set(currentMode, current + HYSTERESIS_BONUS);
+      }
+    }
+
+    // Normalize scores
+    const maxScore = Math.max(...scores.values());
+    const candidates: Array<{ mode: ModeId; score: number }> = [];
+    for (const [mode, score] of scores) {
+      candidates.push({ mode, score: score / maxScore });
+    }
+    candidates.sort((a, b) => b.score - a.score);
+
+    const best = candidates[0];
+    // Confidence is based on the raw normalized score
+    const confidence = best.score;
+
+    if (confidence < 0.4) return null;
+
+    return {
+      mode: best.mode,
+      confidence,
+      candidates,
+    };
+  }
+}