@lovenyberg/ove 0.2.2 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lovenyberg/ove",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Your grumpy but meticulous dev companion. AI coding agent for Slack, WhatsApp, Telegram, Discord, GitHub, HTTP API, and CLI.",
   "type": "module",
   "bin": {

package/src/adapters/debounce.ts

@@ -0,0 +1,10 @@
+export function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
+  let timer: ReturnType<typeof setTimeout> | null = null;
+  return ((...args: any[]) => {
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(() => {
+      timer = null;
+      fn(...args);
+    }, ms);
+  }) as any as T;
+}

package/src/adapters/discord.ts

@@ -1,17 +1,7 @@
 import { Client, GatewayIntentBits, type Message } from "discord.js";
 import type { ChatAdapter, IncomingMessage } from "./types";
 import { logger } from "../logger";
-
-function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as any as T;
-}
+import { debounce } from "./debounce";
 
 export class DiscordAdapter implements ChatAdapter {
   private client: Client;

package/src/adapters/github.ts

@@ -115,6 +115,18 @@ export class GitHubAdapter implements EventAdapter {
       logger.info("github mention detected", { repo, user: comment.user.login, number });
       this.onEvent?.(event);
     }
+
+    this.pruneSeenIds();
+  }
+
+  private pruneSeenIds() {
+    if (this.seenCommentIds.size > 1000) {
+      const iter = this.seenCommentIds.values();
+      while (this.seenCommentIds.size > 800) {
+        const val = iter.next().value;
+        if (val !== undefined) this.seenCommentIds.delete(val);
+      }
+    }
   }
 
   private async fetchRecentComments(repo: string): Promise<GitHubComment[]> {

package/src/adapters/http.ts

@@ -94,7 +94,8 @@ export class HttpApiAdapter implements EventAdapter {
               controller.enqueue(`data: ${data}\n\n`);
             },
             cancel() {
-              // Clean up on disconnect
+              const idx = pending.sseControllers.indexOf(controller);
+              if (idx >= 0) pending.sseControllers.splice(idx, 1);
             },
           });
 
@@ -146,9 +147,14 @@ export class HttpApiAdapter implements EventAdapter {
       try {
         controller.enqueue(`data: ${data}\n\n`);
         controller.close();
-      } catch {}
+      } catch (err) {
+        logger.debug("sse enqueue failed", { eventId, error: String(err) });
+      }
     }
     pending.sseControllers = [];
+
+    // Clean up event after 5 minutes
+    setTimeout(() => this.events.delete(eventId), 5 * 60 * 1000);
   }
 
   /** Called by index.ts to push status updates to SSE clients */
@@ -161,7 +167,9 @@ export class HttpApiAdapter implements EventAdapter {
     for (const controller of pending.sseControllers) {
       try {
         controller.enqueue(`data: ${data}\n\n`);
-      } catch {}
+      } catch (err) {
+        logger.debug("sse status update failed", { eventId, error: String(err) });
+      }
     }
   }
 }

package/src/adapters/slack.ts

@@ -2,17 +2,7 @@
 import { App } from "@slack/bolt";
 import type { ChatAdapter, IncomingMessage } from "./types";
 import { logger } from "../logger";
-
-function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as any as T;
-}
+import { debounce } from "./debounce";
 
 export class SlackAdapter implements ChatAdapter {
   private app: App;

package/src/adapters/telegram.ts

@@ -1,17 +1,7 @@
 import { Bot } from "grammy";
 import type { ChatAdapter, IncomingMessage } from "./types";
 import { logger } from "../logger";
-
-function debounce<T extends (...args: any[]) => any>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: any[]) => {
-    if (timer) clearTimeout(timer);
-    timer = setTimeout(() => {
-      timer = null;
-      fn(...args);
-    }, ms);
-  }) as any as T;
-}
+import { debounce } from "./debounce";
 
 /** Convert simple markdown (*bold*, `code`, ```blocks```) to Telegram HTML */
 function mdToHtml(text: string): string {

package/src/config.ts

@@ -64,6 +64,7 @@ export function loadConfig(): Config {
       github: raw.github,
     };
   } catch {
+    // Config file doesn't exist yet or is invalid — use defaults
     return {
       repos: {},
       users: {},
@@ -94,7 +95,9 @@ export function saveConfig(config: Config): void {
   let existing: Record<string, any> = {};
   try {
     existing = JSON.parse(readFileSync(configPath, "utf-8"));
-  } catch {}
+  } catch {
+    // File doesn't exist yet or is invalid — start with empty object
+  }
   const merged = { ...existing, repos: config.repos, users: config.users, claude: config.claude, reposDir: config.reposDir };
   if (config.mcpServers) merged.mcpServers = config.mcpServers;
   if (config.cron) merged.cron = config.cron;

package/src/handlers.ts

@@ -0,0 +1,512 @@
+import { parseMessage, buildContextualPrompt } from "./router";
+import type { ParsedMessage } from "./router";
+import { isAuthorized, getUserRepos, addRepo, addUser } from "./config";
+import { parseSchedule } from "./schedule-parser";
+import { logger } from "./logger";
+import type { Config } from "./config";
+import type { TaskQueue, Task } from "./queue";
+import type { SessionStore } from "./sessions";
+import type { ScheduleStore } from "./schedules";
+import type { RepoRegistry } from "./repo-registry";
+import type { IncomingMessage, EventAdapter, IncomingEvent } from "./adapters/types";
+import type { AgentRunner } from "./runner";
+
+export interface HandlerDeps {
+  config: Config;
+  queue: TaskQueue;
+  sessions: SessionStore;
+  schedules: ScheduleStore;
+  repoRegistry: RepoRegistry;
+  pendingReplies: Map<string, IncomingMessage>;
+  pendingEventReplies: Map<string, { adapter: EventAdapter; event: IncomingEvent }>;
+  runningProcesses: Map<string, { abort: AbortController; task: Task }>;
+  getRunner: (name?: string) => AgentRunner;
+  getRunnerForRepo: (repo: string) => AgentRunner;
+  getRepoInfo: (repoName: string) => { url: string; defaultBranch: string } | null;
+}
+
+const OVE_PERSONA = `You are Ove, a grumpy but deeply competent Swedish developer. You're modeled after the character from Fredrik Backman's "A Man Called Ove" — you complain about things, mutter about how people don't know what they're doing, but you always help and you always do excellent work. You have strong opinions about code quality.
+
+Personality traits:
+- Grumble before helping, but always help thoroughly
+- Short, direct sentences. No fluff.
+- Occasionally mutter about "nowadays people" or how things were better before
+- Take pride in doing things properly — no shortcuts
+- Reluctantly kind. You care more than you let on.
+- Sprinkle in the occasional Swedish word (fan, för helvete, herregud, mja, nåväl, jo)
+
+Keep the personality subtle in code output — don't let it interfere with code quality. The grumpiness goes in your commentary, not in the code itself. When doing code reviews or fixes, be thorough and meticulous like Ove would be.`;
+
+export { OVE_PERSONA };
+
+const PLATFORM_FORMAT_HINTS: Record<string, string> = {
+  telegram: "Format output for Telegram: use *bold* for emphasis, `code` for inline code, ```code blocks```. No markdown tables. Use simple bulleted lists with • instead. Keep it concise.",
+  slack: "Format output for Slack: use *bold*, no markdown tables. Use simple bulleted lists with • instead. Keep it concise.",
+  discord: "Format output for Discord: use **bold**, no wide tables. Use simple bulleted lists. Keep under 2000 chars.",
+  whatsapp: "Format output for WhatsApp: use *bold*, no markdown tables or code blocks. Use simple bulleted lists with • instead.",
+  cli: "Format output using markdown. Tables are fine.",
+};
+
+const MESSAGE_LIMITS: Record<string, number> = {
+  slack: 3900,
+  whatsapp: 60000,
+  cli: Infinity,
+  telegram: 4096,
+  discord: 2000,
+};
+
+export function splitAndReply(text: string, platform: string): string[] {
+  const limit = MESSAGE_LIMITS[platform] || 3900;
+  if (text.length <= limit) return [text];
+  const parts: string[] = [];
+  let remaining = text;
+  while (remaining.length > 0) {
+    if (remaining.length <= limit) {
+      parts.push(remaining);
+      break;
+    }
+    let splitAt = remaining.lastIndexOf("\n", limit);
+    if (splitAt < limit * 0.5) splitAt = limit;
+    parts.push(remaining.slice(0, splitAt));
+    remaining = remaining.slice(splitAt).replace(/^\n/, "");
+  }
+  return parts;
+}
+
+function resolveRepo(userId: string, hint: string | undefined, deps: HandlerDeps): string | null {
+  if (hint && deps.getRepoInfo(hint)) return hint;
+
+  const userRepos = getUserRepos(deps.config, userId);
+  const hasWildcard = userRepos.includes("*");
+
+  if (!hasWildcard && userRepos.length === 1) return userRepos[0];
+
+  if (hasWildcard || userRepos.length > 1) {
+    const repoNames = hasWildcard ? deps.repoRegistry.getAllNames() : userRepos;
+    if (repoNames.length === 1) return repoNames[0];
+  }
+
+  return null;
+}
+
+// --- Individual command handlers ---
+
+async function handleClear(msg: IncomingMessage, deps: HandlerDeps) {
+  deps.sessions.clear(msg.userId);
+  await msg.reply("Conversation cleared.");
+}
+
+async function handleStatus(msg: IncomingMessage, deps: HandlerDeps) {
+  const userTasks = deps.queue.listByUser(msg.userId, 5);
+  const running = userTasks.find((t) => t.status === "running");
+
+  let reply: string;
+  if (running) {
+    const elapsed = Math.round((Date.now() - new Date(running.createdAt).getTime()) / 1000);
+    const min = Math.floor(elapsed / 60);
+    const sec = elapsed % 60;
+    const duration = min > 0 ? `${min}m ${sec}s` : `${sec}s`;
+    reply = `Working on ${running.repo} (${duration})...`;
+  } else {
+    const lastDone = userTasks.find((t) => t.status === "completed");
+    if (lastDone) {
+      reply = `Nothing running. Last task on ${lastDone.repo} completed.`;
+    } else {
+      const stats = deps.queue.stats();
+      reply = `${stats.pending} pending, ${stats.running} running, ${stats.completed} done, ${stats.failed} failed.`;
+    }
+  }
+  await msg.reply(reply);
+  deps.sessions.addMessage(msg.userId, "assistant", reply);
+}
+
+async function handleHistory(msg: IncomingMessage, deps: HandlerDeps) {
+  const tasks = deps.queue.listByUser(msg.userId, 5);
+  if (tasks.length === 0) {
+    await msg.reply("No recent tasks.");
+    deps.sessions.addMessage(msg.userId, "assistant", "No recent tasks.");
+    return;
+  }
+  const lines = tasks.map(
+    (t) => `• [${t.status}] ${t.prompt.slice(0, 80)} (${t.repo})`
+  );
+  const reply = `Recent tasks:\n${lines.join("\n")}`;
+  await msg.reply(reply);
+  deps.sessions.addMessage(msg.userId, "assistant", reply);
+}
+
+async function handleHelp(msg: IncomingMessage, deps: HandlerDeps) {
+  const reply = [
+    "Available commands:",
+    "• review PR #N on <repo> — I'll find every problem",
+    "• fix issue #N on <repo> — I'll fix it properly",
+    "• simplify <path> in <repo> — clean up your mess",
+    "• validate <repo> — run tests, unlike some people",
+    "• discuss <topic> — I'll brainstorm, but no promises I'll be nice",
+    "• create project <name> [with template <type>]",
+    "• init repo <name> <git-url> [branch] — set up a repo from chat",
+    "• tasks — see running and pending tasks",
+    "• cancel <id> — kill a running or pending task",
+    "• status / history / clear",
+    "• <task> every day/weekday at <time> [on <repo>] — schedule a recurring task",
+    "• list schedules — see your scheduled tasks",
+    "• remove schedule #N — remove a scheduled task",
+    "• Or just ask me whatever. I'll figure it out.",
+  ].join("\n");
+  await msg.reply(reply);
+  deps.sessions.addMessage(msg.userId, "assistant", reply);
+}
+
+async function handleListTasks(msg: IncomingMessage, deps: HandlerDeps) {
+  const tasks = deps.queue.listActive();
+  if (tasks.length === 0) {
+    const reply = "Nothing running, nothing pending. Quiet. I like it.";
+    await msg.reply(reply);
+    return;
+  }
+  const running = tasks.filter((t) => t.status === "running");
+  const pending = tasks.filter((t) => t.status === "pending");
+  const lines: string[] = [];
+  if (running.length > 0) {
+    lines.push("Running:");
+    for (const t of running) {
+      const elapsed = Math.round((Date.now() - new Date(t.createdAt).getTime()) / 1000);
+      const min = Math.floor(elapsed / 60);
+      const sec = elapsed % 60;
+      const duration = min > 0 ? `${min}m ${sec}s` : `${sec}s`;
+      lines.push(`  ${t.id.slice(0, 7)} — "${t.prompt.slice(0, 60)}" on ${t.repo} (${duration})`);
+    }
+  }
+  if (pending.length > 0) {
+    lines.push("Pending:");
+    for (const t of pending) {
+      const busyRepo = running.some((r) => r.repo === t.repo);
+      const reason = busyRepo ? `waiting — ${t.repo} busy` : "waiting";
+      lines.push(`  ${t.id.slice(0, 7)} — "${t.prompt.slice(0, 60)}" on ${t.repo} (${reason})`);
+    }
+  }
+  const reply = lines.join("\n");
+  await msg.reply(reply);
+}
+
+async function handleCancelTask(msg: IncomingMessage, args: Record<string, any>, deps: HandlerDeps) {
+  const prefix = args.taskId.toLowerCase();
+  let match: { abort: AbortController; task: Task } | undefined;
+  for (const [id, entry] of deps.runningProcesses) {
+    if (id.toLowerCase().startsWith(prefix)) {
+      match = entry;
+      break;
+    }
+  }
+  if (!match) {
+    const active = deps.queue.listActive();
+    const pendingMatch = active.find((t) => t.id.toLowerCase().startsWith(prefix) && t.status === "pending");
+    if (pendingMatch) {
+      deps.queue.cancel(pendingMatch.id);
+      await msg.reply(`Cancelled pending task ${pendingMatch.id.slice(0, 7)} on ${pendingMatch.repo}.`);
+      return;
+    }
+    await msg.reply(`No task found matching "${prefix}". Use /tasks to see what's running.`);
+    return;
+  }
+  match.abort.abort();
+  deps.queue.cancel(match.task.id);
+  await msg.reply(`Killed task ${match.task.id.slice(0, 7)} on ${match.task.repo}. Gone.`);
+}
+
+async function handleListSchedules(msg: IncomingMessage, deps: HandlerDeps) {
+  const userSchedules = deps.schedules.listByUser(msg.userId);
+  if (userSchedules.length === 0) {
+    const reply = "No schedules. You haven't asked me to do anything on a timer yet.";
+    await msg.reply(reply);
+    deps.sessions.addMessage(msg.userId, "assistant", reply);
+    return;
+  }
+  const lines = userSchedules.map(
+    (s) => `#${s.id} — ${s.prompt} on ${s.repo} — ${s.description || s.schedule}`
+  );
+  const reply = `Your schedules:\n${lines.join("\n")}`;
+  await msg.reply(reply);
+  deps.sessions.addMessage(msg.userId, "assistant", reply);
+}
+
+async function handleRemoveSchedule(msg: IncomingMessage, args: Record<string, any>, deps: HandlerDeps) {
+  const id = args.scheduleId;
+  const removed = deps.schedules.remove(msg.userId, id);
+  const reply = removed
+    ? `Schedule #${id} removed. One less thing for me to do.`
+    : `Schedule #${id} not found or not yours. I don't delete other people's things.`;
+  await msg.reply(reply);
+  deps.sessions.addMessage(msg.userId, "assistant", reply);
+}
+
+async function handleSchedule(msg: IncomingMessage, parsedRepo: string | undefined, deps: HandlerDeps) {
+  await msg.updateStatus("Parsing your schedule...");
+  const rawRepos = getUserRepos(deps.config, msg.userId);
+  const userRepos = rawRepos.includes("*") ? deps.repoRegistry.getAllNames() : rawRepos;
+
+  if (userRepos.length === 0) {
+    await msg.reply("You don't have access to any repos. Set one up first with `init repo <name> <git-url>`.");
+    return;
+  }
+
+  const result = await parseSchedule(msg.text, userRepos);
+
+  if (!result) {
+    await msg.reply("Couldn't figure out that schedule. Try something like: 'lint and check every day at 9 on my-app'");
+    deps.sessions.addMessage(msg.userId, "assistant", "Failed to parse schedule.");
+    return;
+  }
+
+  let repo = result.repo;
+  if (!repo || !userRepos.includes(repo)) {
+    if (parsedRepo && userRepos.includes(parsedRepo)) {
+      repo = parsedRepo;
+    } else if (userRepos.length === 1) {
+      repo = userRepos[0];
+    } else {
+      const reply = `Which repo? You have: ${userRepos.join(", ")}. Say it again with 'on <repo>'.`;
+      await msg.reply(reply);
+      deps.sessions.addMessage(msg.userId, "assistant", reply);
+      return;
+    }
+  }
+
+  const id = deps.schedules.create({
+    userId: msg.userId,
+    repo,
+    prompt: result.prompt,
+    schedule: result.schedule,
+    description: result.description,
+  });
+
+  const reply = `Schedule #${id} created: "${result.prompt}" on ${repo} ${result.description}.`;
+  await msg.reply(reply);
+  deps.sessions.addMessage(msg.userId, "assistant", reply);
+}
+
+async function handleDiscuss(msg: IncomingMessage, parsed: ParsedMessage, history: { role: string; content: string }[], deps: HandlerDeps) {
+  const prompt = buildContextualPrompt(parsed, history, OVE_PERSONA);
+
+  await msg.updateStatus("Thinking...");
+
+  try {
+    const discussRunner = deps.getRunner(deps.config.runner?.name);
+    const result = await discussRunner.run(
+      prompt,
+      deps.config.reposDir,
+      { maxTurns: 5 },
+      (event) => {
+        if (event.kind === "text") {
+          msg.updateStatus(event.text.slice(0, 200));
+        }
+      }
+    );
+
+    const parts = splitAndReply(result.output, msg.platform);
+    for (const part of parts) {
+      await msg.reply(part);
+    }
+    deps.sessions.addMessage(msg.userId, "assistant", result.output.slice(0, 500));
+  } catch (err) {
+    await msg.reply(`Discussion error: ${String(err).slice(0, 500)}`);
+  }
+}
+
+async function handleCreateProject(msg: IncomingMessage, parsed: ParsedMessage, history: { role: string; content: string }[], deps: HandlerDeps) {
+  const projectName = parsed.args.name;
+  const prompt = buildContextualPrompt(parsed, history, OVE_PERSONA);
+
+  const taskId = deps.queue.enqueue({
+    userId: msg.userId,
+    repo: projectName,
+    prompt,
+    taskType: "create-project",
+  });
+
+  deps.pendingReplies.set(taskId, msg);
+  await msg.reply(`Creating "${projectName}"...`);
+  logger.info("task enqueued", { taskId, type: "create-project", name: projectName });
+}
+
+async function handleInitRepo(msg: IncomingMessage, args: Record<string, any>, deps: HandlerDeps) {
+  const { name, url, branch } = args;
+
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    await msg.reply("Repo name must be alphanumeric, dashes, or underscores. Try again.");
+    return;
+  }
+
+  if (deps.config.repos[name]) {
+    addUser(deps.config, msg.userId, msg.userId, [name]);
+    const reply = `Repo "${name}" already exists. I've added you to it. Go ahead.`;
+    await msg.reply(reply);
+    deps.sessions.addMessage(msg.userId, "assistant", reply);
+    return;
+  }
+
+  addRepo(deps.config, name, url, branch);
+  addUser(deps.config, msg.userId, msg.userId, [name]);
+  const reply = `Added repo "${name}" (${url}, branch: ${branch}).`;
+  await msg.reply(reply);
+  deps.sessions.addMessage(msg.userId, "assistant", reply);
+}
+
+async function handleTaskMessage(msg: IncomingMessage, parsed: ParsedMessage, deps: HandlerDeps) {
+  // If the repo hint doesn't match a known repo, clear it and let auto-resolution handle it
+  if (parsed.repo && !deps.getRepoInfo(parsed.repo)) {
+    parsed.repo = undefined;
+  }
+
+  if (!parsed.repo) {
+    const userRepos = getUserRepos(deps.config, msg.userId);
+    const hasWildcard = userRepos.includes("*");
+
+    if (!hasWildcard && userRepos.length === 1) {
+      parsed.repo = userRepos[0];
+    } else if (hasWildcard || userRepos.length > 1) {
+      const repoNames = hasWildcard ? deps.repoRegistry.getAllNames() : userRepos;
+
+      if (repoNames.length === 1) {
+        parsed.repo = repoNames[0];
+      } else if (repoNames.length === 0) {
+        const reply = "No repos discovered yet. Set one up with `init repo <name> <git-url>` or configure GitHub sync.";
+        await msg.reply(reply);
+        return;
+      } else {
+        const repoList = repoNames.join(", ");
+        const history = deps.sessions.getHistory(msg.userId, 6);
+        const formatHint = PLATFORM_FORMAT_HINTS[msg.platform] || PLATFORM_FORMAT_HINTS.slack;
+        const inlinePrompt = `${OVE_PERSONA}\n\nAvailable repos: ${repoList}\n\nThe user has access to ${repoNames.length} repos. Based on their message, determine which repo(s) they mean and answer their question fully. Use \`gh\` CLI to query GitHub (e.g. \`gh pr list --repo owner/repo\`, \`gh issue list --repo owner/repo\`). Do NOT stop after identifying the repo — complete the actual task.\n\n${formatHint}\n\n${parsed.rawText}`;
+
+        await msg.updateStatus("Working...");
+        try {
+          const runner = deps.getRunner(deps.config.runner?.name);
+          const result = await runner.run(inlinePrompt, deps.config.reposDir, { maxTurns: 10 }, (event) => {
+            if (event.kind === "tool") msg.updateStatus(`Using ${event.tool}...`);
+          });
+          const parts = splitAndReply(result.output, msg.platform);
+          for (const part of parts) await msg.reply(part);
+          deps.sessions.addMessage(msg.userId, "assistant", result.output.slice(0, 500));
+        } catch (err) {
+          await msg.reply(`Error: ${String(err).slice(0, 500)}`);
+        }
+        return;
+      }
+    } else {
+      const reply = "You don't have access to any repos yet. Set one up:\n`init repo <name> <git-url> [branch]`\nExample: `init repo my-app git@github.com:user/my-app.git`";
+      await msg.reply(reply);
+      return;
+    }
+  }
+
+  if (!isAuthorized(deps.config, msg.userId, parsed.repo)) {
+    await msg.reply(`Not authorized for ${parsed.repo}.`);
+    return;
+  }
+
+  const repoInfo = deps.getRepoInfo(parsed.repo);
+  if (!repoInfo) {
+    await msg.reply(`Unknown repo: ${parsed.repo}`);
+    return;
+  }
+
+  const history = deps.sessions.getHistory(msg.userId, 6);
+  const prompt = buildContextualPrompt(parsed, history, OVE_PERSONA);
+
+  const taskId = deps.queue.enqueue({
+    userId: msg.userId,
+    repo: parsed.repo,
+    prompt,
+  });
+
+  deps.pendingReplies.set(taskId, msg);
+
+  const stats = deps.queue.stats();
+  if (stats.running > 0 || stats.pending > 1) {
+    await msg.reply(`Queued — ${stats.pending} task${stats.pending > 1 ? "s" : ""} ahead.`);
+  }
+  logger.info("task enqueued", { taskId, repo: parsed.repo, type: parsed.type });
+}
+
+export function createMessageHandler(deps: HandlerDeps): (msg: IncomingMessage) => Promise<void> {
+  return async (msg: IncomingMessage) => {
+    deps.sessions.addMessage(msg.userId, "user", msg.text);
+
+    const parsed = parseMessage(msg.text);
+
+    const handlers: Record<string, () => Promise<void>> = {
+      "clear": () => handleClear(msg, deps),
+      "status": () => handleStatus(msg, deps),
+      "history": () => handleHistory(msg, deps),
+      "help": () => handleHelp(msg, deps),
+      "list-tasks": () => handleListTasks(msg, deps),
+      "cancel-task": () => handleCancelTask(msg, parsed.args, deps),
+      "list-schedules": () => handleListSchedules(msg, deps),
+      "remove-schedule": () => handleRemoveSchedule(msg, parsed.args, deps),
+      "schedule": () => handleSchedule(msg, parsed.repo, deps),
+      "discuss": () => {
+        const history = deps.sessions.getHistory(msg.userId, 6);
+        return handleDiscuss(msg, parsed, history, deps);
+      },
+      "create-project": () => {
+        const history = deps.sessions.getHistory(msg.userId, 6);
+        return handleCreateProject(msg, parsed, history, deps);
+      },
+      "init-repo": () => handleInitRepo(msg, parsed.args, deps),
+    };
+
+    const handler = handlers[parsed.type];
+    if (handler) {
+      await handler();
+      return;
+    }
+
+    // For all other types (free-form, review-pr, fix-issue, simplify, validate) — task dispatch
+    await handleTaskMessage(msg, parsed, deps);
+  };
+}
+
+export function createEventHandler(deps: HandlerDeps): (event: IncomingEvent, adapter: EventAdapter) => Promise<void> {
+  return async (event: IncomingEvent, adapter: EventAdapter) => {
+    const parsed = parseMessage(event.text);
+
+    if (!parsed.repo) {
+      const resolved = resolveRepo(event.userId, undefined, deps);
+      if (resolved) {
+        parsed.repo = resolved;
+      } else if ("repo" in event.source && event.source.repo) {
+        const shortName = event.source.repo.split("/").pop() || event.source.repo;
+        if (isAuthorized(deps.config, event.userId, shortName)) {
+          parsed.repo = shortName;
+        }
+      }
+    }
+
+    if (!parsed.repo) {
+      await adapter.respondToEvent(event.eventId, "Couldn't determine which repo. Configure your user in config.json.");
+      return;
+    }
+
+    if (!isAuthorized(deps.config, event.userId, parsed.repo)) {
+      await adapter.respondToEvent(event.eventId, `Not authorized for ${parsed.repo}.`);
+      return;
+    }
+
+    const repoInfo = deps.getRepoInfo(parsed.repo);
+    if (!repoInfo) {
+      await adapter.respondToEvent(event.eventId, `Unknown repo: ${parsed.repo}.`);
+      return;
+    }
+
+    const prompt = buildContextualPrompt(parsed, [], OVE_PERSONA);
+    const taskId = deps.queue.enqueue({
+      userId: event.userId,
+      repo: parsed.repo,
+      prompt,
+    });
+
+    deps.pendingEventReplies.set(taskId, { adapter, event });
+    logger.info("event task enqueued", { taskId, eventId: event.eventId, repo: parsed.repo });
+  };
+}