@lovenyberg/ove 0.7.0 → 0.9.0

package/src/router.ts

@@ -16,60 +16,121 @@ export type MessageType =
   | "remove-schedule"
   | "list-tasks"
   | "cancel-task"
-  | "trace";
+  | "trace"
+  | "set-mode";
 
 export interface ParsedMessage {
   type: MessageType;
   repo?: string;
   args: Record<string, any>;
   rawText: string;
+  priority: number;
+}
+
+export function parsePriority(text: string): { priority: number; text: string } {
+  const lower = text.toLowerCase();
+
+  // --priority urgent / --priority high / --priority normal
+  const flagMatch = text.match(/--priority\s+(urgent|high|normal|low)/i);
+  if (flagMatch) {
+    const level = flagMatch[1].toLowerCase();
+    const cleaned = text.replace(/\s*--priority\s+(urgent|high|normal|low)/i, "").trim();
+    const map: Record<string, number> = { urgent: 2, high: 1, normal: 0, low: 0 };
+    return { priority: map[level] ?? 0, text: cleaned };
+  }
+
+  // urgent: prefix
+  if (/^urgent:\s*/i.test(text)) {
+    return { priority: 2, text: text.replace(/^urgent:\s*/i, "").trim() };
+  }
+
+  // !important marker (anywhere)
+  if (/!important\b/i.test(lower)) {
+    return { priority: 1, text: text.replace(/\s*!important/i, "").trim() };
+  }
+
+  // p1 / p2 / p3 markers
+  const pMatch = text.match(/\bp([0-3])\b/i);
+  if (pMatch) {
+    const pNum = parseInt(pMatch[1]);
+    // p0 = urgent (2), p1 = high (1), p2 = normal (0), p3 = normal (0)
+    const map: Record<number, number> = { 0: 2, 1: 1, 2: 0, 3: 0 };
+    const cleaned = text.replace(/\s*\bp[0-3]\b/i, "").trim();
+    return { priority: map[pNum] ?? 0, text: cleaned };
+  }
+
+  return { priority: 0, text };
 }
 
 export function parseMessage(text: string): ParsedMessage {
-  const trimmed = text.trim();
+  const { priority, text: priorityStripped } = parsePriority(text.trim());
+  const trimmed = priorityStripped;
   const lower = trimmed.toLowerCase();
 
+  function msg(partial: Omit<ParsedMessage, "priority">): ParsedMessage {
+    return { ...partial, priority };
+  }
+
   // Handle Telegram /commands — strip leading slash
-  if (lower === "/start") return { type: "help", args: {}, rawText: trimmed };
-  if (lower === "/help") return { type: "help", args: {}, rawText: trimmed };
-  if (lower === "/status") return { type: "status", args: {}, rawText: trimmed };
-  if (lower === "/history") return { type: "history", args: {}, rawText: trimmed };
-  if (lower === "/clear") return { type: "clear", args: {}, rawText: trimmed };
+  if (lower === "/start") return msg({ type: "help", args: {}, rawText: trimmed });
+  if (lower === "/help") return msg({ type: "help", args: {}, rawText: trimmed });
+  if (lower === "/status") return msg({ type: "status", args: {}, rawText: trimmed });
+  if (lower === "/history") return msg({ type: "history", args: {}, rawText: trimmed });
+  if (lower === "/clear") return msg({ type: "clear", args: {}, rawText: trimmed });
 
-  if (lower === "status") return { type: "status", args: {}, rawText: trimmed };
-  if (lower === "history" || lower === "my tasks") return { type: "history", args: {}, rawText: trimmed };
-  if (lower === "help") return { type: "help", args: {}, rawText: trimmed };
-  if (lower === "clear" || lower === "reset") return { type: "clear", args: {}, rawText: trimmed };
+  if (lower === "status") return msg({ type: "status", args: {}, rawText: trimmed });
+  if (lower === "history" || lower === "my tasks") return msg({ type: "history", args: {}, rawText: trimmed });
+  if (lower === "help") return msg({ type: "help", args: {}, rawText: trimmed });
+  if (lower === "clear" || lower === "reset") return msg({ type: "clear", args: {}, rawText: trimmed });
 
   // Task management
-  if (lower === "tasks" || lower === "/tasks") return { type: "list-tasks", args: {}, rawText: trimmed };
+  if (lower === "tasks" || lower === "/tasks") return msg({ type: "list-tasks", args: {}, rawText: trimmed });
   const cancelMatch = trimmed.match(/^(?:\/)?cancel\s+(\S+)$/i);
-  if (cancelMatch) return { type: "cancel-task", args: { taskId: cancelMatch[1] }, rawText: trimmed };
+  if (cancelMatch) return msg({ type: "cancel-task", args: { taskId: cancelMatch[1] }, rawText: trimmed });
 
   const traceMatch = trimmed.match(/^(?:\/)?trace(?:\s+(\S+))?$/i);
-  if (traceMatch) return { type: "trace", args: { taskId: traceMatch[1] }, rawText: trimmed };
+  if (traceMatch) return msg({ type: "trace", args: { taskId: traceMatch[1] }, rawText: trimmed });
+
+  // Mode switching — explicit commands
+  const modeMatch = trimmed.match(/^(?:\/)?mode\s+(assistant|strict)$/i);
+  if (modeMatch) {
+    return msg({ type: "set-mode", args: { mode: modeMatch[1].toLowerCase() }, rawText: trimmed });
+  }
+
+  // Mode switching — natural language for assistant mode
+  if (/^(?:assistant|yolo)\s+mode$/i.test(lower) ||
+      /^be\s+more\s+helpful$/i.test(lower) ||
+      /^help\s+me\s+with\s+(?:anything|everything)$/i.test(lower)) {
+    return msg({ type: "set-mode", args: { mode: "assistant" }, rawText: trimmed });
+  }
+
+  // Mode switching — natural language for strict mode
+  if (/^(?:strict|code|normal)\s+mode$/i.test(lower) ||
+      /^back\s+to\s+(?:normal|code|strict)$/i.test(lower)) {
+    return msg({ type: "set-mode", args: { mode: "strict" }, rawText: trimmed });
+  }
 
   // Natural language status inquiries — short messages asking about progress
-  if (isStatusInquiry(lower)) return { type: "status", args: {}, rawText: trimmed };
+  if (isStatusInquiry(lower)) return msg({ type: "status", args: {}, rawText: trimmed });
 
   const prMatch = trimmed.match(/review\s+pr\s+#?(\d+)\s+(?:on|in)\s+(\S+)/i);
   if (prMatch) {
-    return { type: "review-pr", repo: prMatch[2], args: { prNumber: parseInt(prMatch[1]) }, rawText: trimmed };
+    return msg({ type: "review-pr", repo: prMatch[2], args: { prNumber: parseInt(prMatch[1]) }, rawText: trimmed });
   }
 
   const issueMatch = trimmed.match(/fix\s+issue\s+#?(\d+)\s+(?:on|in)\s+(\S+)/i);
   if (issueMatch) {
-    return { type: "fix-issue", repo: issueMatch[2], args: { issueNumber: parseInt(issueMatch[1]) }, rawText: trimmed };
+    return msg({ type: "fix-issue", repo: issueMatch[2], args: { issueNumber: parseInt(issueMatch[1]) }, rawText: trimmed });
   }
 
   const simplifyMatch = trimmed.match(/simplify\s+(\S+)\s+(?:on|in)\s+(\S+)/i);
   if (simplifyMatch) {
-    return { type: "simplify", repo: simplifyMatch[2], args: { filePath: simplifyMatch[1] }, rawText: trimmed };
+    return msg({ type: "simplify", repo: simplifyMatch[2], args: { filePath: simplifyMatch[1] }, rawText: trimmed });
   }
 
   const validateMatch = trimmed.match(/validate\s+(\S+)/i);
   if (validateMatch) {
-    return { type: "validate", repo: validateMatch[1], args: {}, rawText: trimmed };
+    return msg({ type: "validate", repo: validateMatch[1], args: {}, rawText: trimmed });
   }
 
   // create project <name> [with template <type>]
@@ -77,43 +138,43 @@ export function parseMessage(text: string): ParsedMessage {
   if (createMatch) {
     const args: Record<string, any> = { name: createMatch[1] };
     if (createMatch[2]) args.template = createMatch[2];
-    return { type: "create-project", args, rawText: trimmed };
+    return msg({ type: "create-project", args, rawText: trimmed });
   }
 
   // Schedule management
   if (/list\s+schedules|show\s+(?:my\s+)?schedules|what.?s\s+scheduled/i.test(lower)) {
-    return { type: "list-schedules", args: {}, rawText: trimmed };
+    return msg({ type: "list-schedules", args: {}, rawText: trimmed });
   }
 
   const removeScheduleMatch = trimmed.match(/(?:remove|delete|cancel)\s+schedule\s+#?(\d+)/i);
   if (removeScheduleMatch) {
-    return { type: "remove-schedule", args: { scheduleId: parseInt(removeScheduleMatch[1]) }, rawText: trimmed };
+    return msg({ type: "remove-schedule", args: { scheduleId: parseInt(removeScheduleMatch[1]) }, rawText: trimmed });
   }
 
   // Schedule creation — detect natural language scheduling intent
   if (/\b(?:every\s+(?:day|week|month|monday|tuesday|wednesday|thursday|friday|saturday|sunday|weekday|morning|evening|hour|(?:\d+\s+)?(?:min(?:ute)?s?|hours?))|each\s+(?:day|week|weekday)|daily|weekly|monthly)\b/i.test(lower) ||
       /\b(?:at\s+\d{1,2}(?::\d{2})?)\b.*\b(?:every|each|daily|weekly)\b/i.test(lower)) {
     const repoHint = trimmed.match(/(?:in|on)\s+(\S+)\s*$/i);
-    return { type: "schedule", repo: repoHint?.[1], args: {}, rawText: trimmed };
+    return msg({ type: "schedule", repo: repoHint?.[1], args: {}, rawText: trimmed });
   }
 
   // discuss / brainstorm / "I have an idea"
   const discussMatch = trimmed.match(/^(?:discuss|brainstorm)\s+(.+)/i);
   if (discussMatch) {
-    return { type: "discuss", args: { topic: discussMatch[1] }, rawText: trimmed };
+    return msg({ type: "discuss", args: { topic: discussMatch[1] }, rawText: trimmed });
   }
   if (/^i\s+have\s+(?:a|an)\s+(?:idea|new\s+idea)/i.test(lower)) {
-    return { type: "discuss", args: { topic: trimmed }, rawText: trimmed };
+    return msg({ type: "discuss", args: { topic: trimmed }, rawText: trimmed });
   }
 
   // init repo <name> <url> [branch]
   const initRepoMatch = trimmed.match(/^(?:init|setup|add)\s+repo\s+(\S+)\s+((?:git@|https:\/\/)\S+)(?:\s+(\S+))?$/i);
   if (initRepoMatch) {
-    return {
+    return msg({
       type: "init-repo",
       args: { name: initRepoMatch[1], url: initRepoMatch[2], branch: initRepoMatch[3] || "main" },
       rawText: trimmed,
-    };
+    });
   }
 
   // Natural language repo setup: "clone org/repo", "setup org/repo", "add org/repo"
@@ -122,11 +183,11 @@ export function parseMessage(text: string): ParsedMessage {
     const slug = naturalRepoMatch[1];
     const name = slug.split("/").pop()!;
     const url = `git@github.com:${slug}.git`;
-    return {
+    return msg({
       type: "init-repo",
       args: { name, url, branch: "main" },
       rawText: trimmed,
-    };
+    });
   }
 
   // Detect org/repo or GitHub URLs anywhere in a message that looks like a setup request
@@ -137,27 +198,27 @@ export function parseMessage(text: string): ParsedMessage {
       const slug = ghUrl[2];
       const name = slug.split("/").pop()!;
       const url = ghUrl[1].endsWith(".git") ? ghUrl[1] : ghUrl[1] + ".git";
-      return {
+      return msg({
         type: "init-repo",
         args: { name, url: url.startsWith("git@") ? url : `git@github.com:${slug}.git`, branch: "main" },
         rawText: trimmed,
-      };
+      });
     }
     const slugMatch = trimmed.match(/\b([a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+)\b/);
     if (slugMatch && slugMatch[1].indexOf("/") > 0) {
       const slug = slugMatch[1];
       const name = slug.split("/").pop()!;
       const url = `git@github.com:${slug}.git`;
-      return {
+      return msg({
         type: "init-repo",
         args: { name, url, branch: "main" },
         rawText: trimmed,
-      };
+      });
     }
   }
 
   const repoHint = trimmed.match(/(?:in|on)\s+(\S+?)[?.!,]*\s*$/i);
-  return { type: "free-form", repo: repoHint?.[1], args: {}, rawText: trimmed };
+  return msg({ type: "free-form", repo: repoHint?.[1], args: {}, rawText: trimmed });
 }
 
 // Detect natural language status/progress inquiries.

package/src/sessions.test.ts

@@ -42,4 +42,45 @@ describe("SessionStore", () => {
     store.clear("slack:U123");
     expect(store.getHistory("slack:U123").length).toBe(0);
   });
+
+  describe("user modes", () => {
+    it("returns 'strict' as default mode", () => {
+      const mode = store.getMode("slack:U123");
+      expect(mode).toBe("strict");
+    });
+
+    it("stores and retrieves a mode", () => {
+      store.setMode("slack:U123", "assistant");
+      expect(store.getMode("slack:U123")).toBe("assistant");
+    });
+
+    it("upserts mode (overwrites previous)", () => {
+      store.setMode("slack:U123", "assistant");
+      store.setMode("slack:U123", "strict");
+      expect(store.getMode("slack:U123")).toBe("strict");
+    });
+
+    it("keeps separate modes per user", () => {
+      store.setMode("slack:U1", "assistant");
+      store.setMode("slack:U2", "strict");
+      expect(store.getMode("slack:U1")).toBe("assistant");
+      expect(store.getMode("slack:U2")).toBe("strict");
+    });
+
+    it("resets mode when session is cleared", () => {
+      store.setMode("slack:U123", "assistant");
+      store.clear("slack:U123");
+      expect(store.getMode("slack:U123")).toBe("strict");
+    });
+
+    it("falls back to strict for unexpected values in database", () => {
+      // Simulate a corrupted/unexpected value by writing directly to SQLite
+      const db = (store as any).db as Database;
+      db.run(
+        `INSERT INTO user_modes (user_id, mode, updated_at) VALUES (?, ?, ?)`,
+        ["slack:U999", "banana", new Date().toISOString()]
+      );
+      expect(store.getMode("slack:U999")).toBe("strict");
+    });
+  });
 });

package/src/sessions.ts

@@ -1,5 +1,7 @@
 import { Database } from "bun:sqlite";
 
+export type UserMode = "strict" | "assistant";
+
 export interface ChatMessage {
   role: "user" | "assistant";
   content: string;
@@ -27,6 +29,13 @@ export class SessionStore {
       )
     `);
     this.db.run(`CREATE INDEX IF NOT EXISTS idx_chat_user ON chat_history(user_id)`);
+    this.db.run(`
+      CREATE TABLE IF NOT EXISTS user_modes (
+        user_id TEXT PRIMARY KEY,
+        mode TEXT NOT NULL,
+        updated_at TEXT NOT NULL
+      )
+    `);
   }
 
   addMessage(userId: string, role: "user" | "assistant", content: string) {
@@ -55,7 +64,25 @@ export class SessionStore {
       }));
   }
 
+  getMode(userId: string): UserMode {
+    const row = this.db
+      .query(`SELECT mode FROM user_modes WHERE user_id = ?`)
+      .get(userId) as { mode: string } | null;
+    if (!row) return "strict";
+    if (row.mode === "assistant" || row.mode === "strict") return row.mode;
+    return "strict";
+  }
+
+  setMode(userId: string, mode: UserMode): void {
+    this.db.run(
+      `INSERT INTO user_modes (user_id, mode, updated_at) VALUES (?, ?, ?)
+       ON CONFLICT(user_id) DO UPDATE SET mode = excluded.mode, updated_at = excluded.updated_at`,
+      [userId, mode, new Date().toISOString()]
+    );
+  }
+
   clear(userId: string) {
     this.db.run(`DELETE FROM chat_history WHERE user_id = ?`, [userId]);
+    this.db.run(`DELETE FROM user_modes WHERE user_id = ?`, [userId]);
   }
 }

package/src/setup.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, accessSync, constants } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { resolve, dirname } from "node:path";
 import { userInfo } from "node:os";
@@ -10,6 +10,165 @@ interface ValidationResult {
   issues: string[];
 }
 
+export interface DiagnosticResult {
+  name: string;
+  status: "pass" | "fail" | "warn";
+  message: string;
+}
+
+export interface DiagnosticDeps {
+  which: (cmd: string) => string | null;
+  fetch: typeof globalThis.fetch;
+  spawn: typeof Bun.spawn;
+  accessSync: typeof accessSync;
+  existsSync: typeof existsSync;
+}
+
+const defaultDeps: DiagnosticDeps = {
+  which: (cmd: string) => Bun.which(cmd),
+  fetch: globalThis.fetch,
+  spawn: Bun.spawn,
+  accessSync,
+  existsSync,
+};
+
+export async function runDiagnostics(config: Config, deps: DiagnosticDeps = defaultDeps): Promise<DiagnosticResult[]> {
+  const results: DiagnosticResult[] = [];
+
+  // Check git installed
+  const gitPath = deps.which("git");
+  if (gitPath) {
+    let version = "";
+    try {
+      const proc = deps.spawn(["git", "--version"], { stdout: "pipe", stderr: "pipe" });
+      await proc.exited;
+      version = await new Response(proc.stdout).text();
+      const match = version.match(/(\d+\.\d+[\.\d]*)/);
+      results.push({ name: "git", status: "pass", message: `git installed (${match ? match[1] : "unknown version"})` });
+    } catch {
+      results.push({ name: "git", status: "pass", message: "git installed" });
+    }
+  } else {
+    results.push({ name: "git", status: "fail", message: "git not found" });
+  }
+
+  // Check runner CLI installed (claude or codex)
+  const runnerName = config.runner?.name || "claude";
+  const runnerCmd = runnerName === "codex" ? "codex" : "claude";
+  const runnerPath = deps.which(runnerCmd);
+  if (runnerPath) {
+    results.push({ name: runnerCmd, status: "pass", message: `${runnerCmd} CLI installed` });
+  } else {
+    results.push({ name: runnerCmd, status: "fail", message: `${runnerCmd} CLI not found` });
+  }
+
+  // Check gh CLI installed (if GitHub sync configured)
+  const hasGitHubSync = !!(config.github?.orgs && config.github.orgs.length > 0);
+  const hasGitHubPoll = !!process.env.GITHUB_POLL_REPOS;
+  if (hasGitHubSync || hasGitHubPoll) {
+    const ghPath = deps.which("gh");
+    if (ghPath) {
+      results.push({ name: "gh", status: "pass", message: "gh CLI installed" });
+    } else {
+      results.push({ name: "gh", status: "warn", message: "gh CLI not found (GitHub sync will not work)" });
+    }
+  }
+
+  // Check SSH access to GitHub
+  try {
+    const proc = deps.spawn(
+      ["ssh", "-T", "git@github.com", "-o", "BatchMode=yes", "-o", "ConnectTimeout=5"],
+      { stdout: "pipe", stderr: "pipe" }
+    );
+    const exitCode = await proc.exited;
+    // GitHub SSH returns exit code 1 with "successfully authenticated" on success
+    const stderr = await new Response(proc.stderr).text();
+    if (exitCode === 0 || exitCode === 1 && stderr.includes("successfully authenticated")) {
+      results.push({ name: "ssh", status: "pass", message: "SSH access to github.com" });
+    } else {
+      results.push({ name: "ssh", status: "warn", message: "SSH access to github.com failed (HTTPS clones still work)" });
+    }
+  } catch {
+    results.push({ name: "ssh", status: "warn", message: "SSH access to github.com failed (HTTPS clones still work)" });
+  }
+
+  // Check REPOS_DIR exists and is writable
+  const reposDir = config.reposDir;
+  if (deps.existsSync(reposDir)) {
+    try {
+      deps.accessSync(reposDir, constants.W_OK);
+      results.push({ name: "repos_dir", status: "pass", message: `REPOS_DIR ${reposDir} exists and is writable` });
+    } catch {
+      results.push({ name: "repos_dir", status: "fail", message: `REPOS_DIR ${reposDir} exists but is not writable` });
+    }
+  } else {
+    results.push({ name: "repos_dir", status: "fail", message: `REPOS_DIR ${reposDir} does not exist` });
+  }
+
+  // Check bot token validity via API calls
+  const slackToken = process.env.SLACK_BOT_TOKEN;
+  if (slackToken && slackToken !== "xoxb-...") {
+    try {
+      const res = await deps.fetch("https://slack.com/api/auth.test", {
+        method: "POST",
+        headers: { Authorization: `Bearer ${slackToken}`, "Content-Type": "application/json" },
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json() as { ok: boolean };
+      if (data.ok) {
+        results.push({ name: "slack", status: "pass", message: "Slack bot token is valid" });
+      } else {
+        results.push({ name: "slack", status: "fail", message: "Slack bot token is invalid" });
+      }
+    } catch {
+      results.push({ name: "slack", status: "warn", message: "Could not verify Slack bot token (network error)" });
+    }
+  }
+
+  const telegramToken = process.env.TELEGRAM_BOT_TOKEN;
+  if (telegramToken) {
+    try {
+      const res = await deps.fetch(`https://api.telegram.org/bot${telegramToken}/getMe`, {
+        signal: AbortSignal.timeout(5000),
+      });
+      const data = await res.json() as { ok: boolean };
+      if (data.ok) {
+        results.push({ name: "telegram", status: "pass", message: "Telegram bot token is valid" });
+      } else {
+        results.push({ name: "telegram", status: "fail", message: "Telegram bot token is invalid" });
+      }
+    } catch {
+      results.push({ name: "telegram", status: "warn", message: "Could not verify Telegram bot token (network error)" });
+    }
+  }
+
+  const discordToken = process.env.DISCORD_BOT_TOKEN;
+  if (discordToken) {
+    try {
+      const res = await deps.fetch("https://discord.com/api/v10/users/@me", {
+        headers: { Authorization: `Bot ${discordToken}` },
+        signal: AbortSignal.timeout(5000),
+      });
+      if (res.ok) {
+        results.push({ name: "discord", status: "pass", message: "Discord bot token is valid" });
+      } else {
+        results.push({ name: "discord", status: "fail", message: "Discord bot token is invalid" });
+      }
+    } catch {
+      results.push({ name: "discord", status: "warn", message: "Could not verify Discord bot token (network error)" });
+    }
+  }
+
+  return results;
+}
+
+export function printDiagnostics(results: DiagnosticResult[]): void {
+  const icons = { pass: "\u2713", fail: "\u2717", warn: "\u26A0" };
+  for (const r of results) {
+    process.stdout.write(`  ${icons[r.status]} ${r.message}\n`);
+  }
+}
+
 export function validateConfig(opts?: { configPath?: string; envPath?: string }): ValidationResult {
   const configPath = opts?.configPath || process.env.CONFIG_PATH || "./config.json";
   const envPath = opts?.envPath || "./.env";

package/src/smoke.test.ts

@@ -1,9 +1,10 @@
 import { describe, it, expect } from "bun:test";
 import { Database } from "bun:sqlite";
-import { parseMessage, buildPrompt } from "./router";
+import { parseMessage, buildPrompt, buildContextualPrompt } from "./router";
 import { TaskQueue } from "./queue";
 import { ClaudeRunner } from "./runners/claude";
 import { SessionStore } from "./sessions";
+import { OVE_PERSONA } from "./handlers";
 
 describe("smoke test: full message flow", () => {
   it("routes a PR review through the full pipeline", () => {
@@ -77,4 +78,33 @@ describe("smoke test: full message flow", () => {
     expect(task).not.toBeNull();
     expect(task!.prompt).toContain("auth middleware");
   });
+
+  it("mode switch changes persona in prompts", () => {
+    const db = new Database(":memory:");
+    const sessions = new SessionStore(db);
+    const parsed = parseMessage("explain the auth flow");
+
+    // Default mode — prompt should NOT contain assistant addendum
+    const strictPrompt = buildContextualPrompt(parsed, [], OVE_PERSONA);
+    expect(strictPrompt).toContain("grumpy");
+    expect(strictPrompt).not.toContain("IMPORTANT MODE OVERRIDE");
+
+    // Switch to assistant — prompt should contain the addendum
+    sessions.setMode("slack:U123", "assistant");
+    expect(sessions.getMode("slack:U123")).toBe("assistant");
+
+    const assistantPersona = OVE_PERSONA + "\n\n" + "IMPORTANT MODE OVERRIDE";
+    const assistantPrompt = buildContextualPrompt(parsed, [], assistantPersona);
+    expect(assistantPrompt).toContain("IMPORTANT MODE OVERRIDE");
+    expect(assistantPrompt).toContain("grumpy");
+
+    // Switch back — verify storage round-trips
+    sessions.setMode("slack:U123", "strict");
+    expect(sessions.getMode("slack:U123")).toBe("strict");
+
+    // Verify parseMessage detects mode commands
+    const modeCmd = parseMessage("mode assistant");
+    expect(modeCmd.type).toBe("set-mode");
+    expect(modeCmd.args.mode).toBe("assistant");
+  });
 });