@lovenyberg/ove 0.3.0 → 0.4.0

package/src/adapters/slack.ts

@@ -1,12 +1,14 @@
 // src/adapters/slack.ts
 import { App } from "@slack/bolt";
-import type { ChatAdapter, IncomingMessage } from "./types";
+import type { ChatAdapter, IncomingMessage, AdapterStatus } from "./types";
 import { logger } from "../logger";
 import { debounce } from "./debounce";
 
 export class SlackAdapter implements ChatAdapter {
   private app: App;
   private onMessage?: (msg: IncomingMessage) => void;
+  private started = false;
+  private startedAt?: string;
 
   constructor() {
     this.app = new App({
@@ -32,7 +34,8 @@ export class SlackAdapter implements ChatAdapter {
             ts: statusMsgTs,
             text: statusText,
           });
-        } catch {
+        } catch (err) {
+          logger.warn("slack status update failed", { error: String(err) });
           const result = await say(statusText);
           if (result && "ts" in result) statusMsgTs = result.ts;
         }
@@ -86,10 +89,22 @@ export class SlackAdapter implements ChatAdapter {
     });
 
     await this.app.start();
+    this.started = true;
+    this.startedAt = new Date().toISOString();
     logger.info("slack adapter started");
   }
 
+  getStatus(): AdapterStatus {
+    return {
+      name: "slack",
+      type: "chat",
+      status: this.started ? "connected" : "disconnected",
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
+    this.started = false;
     await this.app.stop();
     logger.info("slack adapter stopped");
   }

package/src/adapters/telegram.ts

@@ -1,5 +1,5 @@
 import { Bot } from "grammy";
-import type { ChatAdapter, IncomingMessage } from "./types";
+import type { ChatAdapter, IncomingMessage, AdapterStatus } from "./types";
 import { logger } from "../logger";
 import { debounce } from "./debounce";
 
@@ -24,6 +24,8 @@ function mdToHtml(text: string): string {
 export class TelegramAdapter implements ChatAdapter {
   private bot: Bot;
   private onMessage?: (msg: IncomingMessage) => void;
+  private started = false;
+  private startedAt?: string;
 
   constructor(token: string) {
     if (!token) throw new Error("Telegram bot token is required");
@@ -51,8 +53,8 @@ export class TelegramAdapter implements ChatAdapter {
             const sent = await ctx.reply(html, { parse_mode: "HTML" });
             statusMsgId = sent.message_id;
           }
-        } catch {
-          // Edit may fail if content unchanged or message too old — ignore
+        } catch (err) {
+          logger.warn("telegram status update failed", { error: String(err) });
         }
       }, 3000);
 
@@ -61,14 +63,12 @@ export class TelegramAdapter implements ChatAdapter {
         platform: "telegram",
         text,
         reply: async (replyText: string) => {
-          // Replace the status message with the first reply, then send new messages for the rest
+          // Delete status message and send a new one so the user gets a notification
           if (statusMsgId) {
             try {
-              await ctx.api.editMessageText(chatId, statusMsgId, mdToHtml(replyText), { parse_mode: "HTML" });
-              statusMsgId = undefined;
-              return;
-            } catch {
-              // Edit failed (message too old, etc.) — fall through to send new
+              await ctx.api.deleteMessage(chatId, statusMsgId);
+            } catch (err) {
+              logger.debug("telegram status delete failed", { error: String(err) });
             }
             statusMsgId = undefined;
           }
@@ -82,10 +82,22 @@ export class TelegramAdapter implements ChatAdapter {
     });
 
     this.bot.start();
+    this.started = true;
+    this.startedAt = new Date().toISOString();
     logger.info("telegram adapter started");
   }
 
+  getStatus(): AdapterStatus {
+    return {
+      name: "telegram",
+      type: "chat",
+      status: this.started ? "connected" : "disconnected",
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
+    this.started = false;
     this.bot.stop();
     logger.info("telegram adapter stopped");
   }

package/src/adapters/types.ts

@@ -6,10 +6,20 @@ export interface IncomingMessage {
   updateStatus: (text: string) => Promise<void>;
 }
 
+export interface AdapterStatus {
+  name: string;
+  type: "chat" | "event";
+  status: "connected" | "disconnected" | "degraded" | "unknown";
+  error?: string;
+  details?: Record<string, unknown>;
+  startedAt?: string;
+}
+
 export interface ChatAdapter {
   start(onMessage: (msg: IncomingMessage) => void): Promise<void>;
   stop(): Promise<void>;
   sendToUser?(userId: string, text: string): Promise<void>;
+  getStatus?(): AdapterStatus;
 }
 
 export type EventSource =
@@ -29,4 +39,5 @@ export interface EventAdapter {
   start(onEvent: (event: IncomingEvent) => void): Promise<void>;
   stop(): Promise<void>;
   respondToEvent(eventId: string, text: string): Promise<void>;
+  getStatus?(): AdapterStatus;
 }

package/src/adapters/whatsapp.ts

@@ -4,7 +4,7 @@ import makeWASocket, {
   DisconnectReason,
   type WASocket,
 } from "baileys";
-import type { ChatAdapter, IncomingMessage } from "./types";
+import type { ChatAdapter, IncomingMessage, AdapterStatus } from "./types";
 import { logger } from "../logger";
 
 export class WhatsAppAdapter implements ChatAdapter {
@@ -12,12 +12,18 @@ export class WhatsAppAdapter implements ChatAdapter {
   private onMessage?: (msg: IncomingMessage) => void;
   private authDir: string;
   private phoneNumber?: string;
+  private allowedChats: Set<string>;
   private reconnectAttempt = 0;
   private sentByBot = new Set<string>();
+  private connectionState: "open" | "close" | "connecting" = "connecting";
+  private lastError?: string;
+  private startedAt?: string;
+  private pairingCode?: string;
 
-  constructor(opts: { authDir?: string; phoneNumber?: string } = {}) {
+  constructor(opts: { authDir?: string; phoneNumber?: string; allowedChats?: string[] } = {}) {
     this.authDir = opts.authDir ?? "./auth/whatsapp";
     this.phoneNumber = opts.phoneNumber;
+    this.allowedChats = new Set(opts.allowedChats ?? []);
   }
 
   async start(onMessage: (msg: IncomingMessage) => void): Promise<void> {
@@ -33,13 +39,17 @@ export class WhatsAppAdapter implements ChatAdapter {
 
     let pairingRequested = false;
 
+    this.startedAt = this.startedAt || new Date().toISOString();
+
     this.sock.ev.on("connection.update", async ({ connection, lastDisconnect, qr }) => {
+      if (connection) this.connectionState = connection as "open" | "close" | "connecting";
       // Request pairing code when server is ready (sends qr event)
       if (qr && this.phoneNumber && !pairingRequested) {
         pairingRequested = true;
         try {
           const phone = this.phoneNumber.replace(/[^0-9]/g, "");
           const code = await this.sock!.requestPairingCode(phone);
+          this.pairingCode = code;
           logger.info(`whatsapp pairing code: ${code}`, { phone });
           console.log(`\n  WhatsApp pairing code: ${code}`);
           console.log(`  Enter this code on your phone: WhatsApp → Linked Devices → Link a Device\n`);
@@ -50,16 +60,20 @@ export class WhatsAppAdapter implements ChatAdapter {
 
       if (connection === "close") {
         const statusCode = (lastDisconnect?.error as any)?.output?.statusCode;
+        this.lastError = `disconnected (status ${statusCode})`;
         if (statusCode !== DisconnectReason.loggedOut) {
           this.reconnectAttempt++;
           const delay = Math.min(2000 * this.reconnectAttempt, 30_000);
           logger.warn("whatsapp disconnected, reconnecting...", { statusCode, delay });
           setTimeout(() => this.start(onMessage), delay);
         } else {
+          this.lastError = "logged out";
           logger.error("whatsapp logged out");
         }
       } else if (connection === "open") {
         this.reconnectAttempt = 0;
+        this.lastError = undefined;
+        this.pairingCode = undefined;
         logger.info("whatsapp adapter connected");
       }
     });
@@ -78,6 +92,14 @@ export class WhatsAppAdapter implements ChatAdapter {
         // Skip messages from others (not our phone) — we only process our own commands
         if (!waMsg.key.fromMe) continue;
 
+        // Only process messages in whitelisted chats (if configured)
+        if (this.allowedChats.size > 0) {
+          const jid = waMsg.key.remoteJid;
+          if (!jid) continue;
+          const chatId = jid.split("@")[0];
+          if (!this.allowedChats.has(jid) && !this.allowedChats.has(chatId)) continue;
+        }
+
         const text =
           waMsg.message.conversation ||
           waMsg.message.extendedTextMessage?.text;
@@ -141,6 +163,22 @@ export class WhatsAppAdapter implements ChatAdapter {
     });
   }
 
+  getStatus(): AdapterStatus {
+    let status: AdapterStatus["status"] = "unknown";
+    if (this.connectionState === "open") status = "connected";
+    else if (this.connectionState === "close") status = "disconnected";
+    else if (this.connectionState === "connecting") status = this.reconnectAttempt > 0 ? "degraded" : "unknown";
+
+    return {
+      name: "whatsapp",
+      type: "chat",
+      status,
+      error: this.lastError,
+      details: { reconnectAttempt: this.reconnectAttempt, pairingCode: this.pairingCode },
+      startedAt: this.startedAt,
+    };
+  }
+
   async stop(): Promise<void> {
     this.sock?.end(undefined);
     this.sock = null;

package/src/flows.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach } from "bun:test";
 import { Database } from "bun:sqlite";
 import { parseMessage, buildPrompt, buildContextualPrompt, type ParsedMessage } from "./router";
 import { TaskQueue } from "./queue";
+import { SessionStore } from "./sessions";
 
 describe("Conversational flow routing", () => {
   describe("discuss flows", () => {
@@ -238,6 +239,26 @@ describe("buildContextualPrompt", () => {
   });
 });
 
+describe("Conversation-aware repo resolution", () => {
+  it("derives lastRepo from recent task history", () => {
+    const db = new Database(":memory:");
+    db.run("PRAGMA journal_mode = WAL");
+    const queue = new TaskQueue(db);
+
+    const taskId = queue.enqueue({
+      userId: "telegram:U1",
+      repo: "iris",
+      prompt: "check the roadmap",
+    });
+    queue.dequeue();
+    queue.complete(taskId, "Here's the roadmap...");
+
+    const recent = queue.listByUser("telegram:U1", 1);
+    expect(recent.length).toBe(1);
+    expect(recent[0].repo).toBe("iris");
+  });
+});
+
 describe("Queue round-trip with taskType", () => {
   let queue: TaskQueue;
 
@@ -310,3 +331,108 @@ describe("Queue round-trip with taskType", () => {
     expect(task!.taskType).toBeNull();
   });
 });
+
+describe("Full follow-up conversation flow", () => {
+  it("follow-up message without repo uses last task's repo", () => {
+    const db = new Database(":memory:");
+    db.run("PRAGMA journal_mode = WAL");
+    const queue = new TaskQueue(db);
+    const sessions = new SessionStore(db);
+
+    // Simulate conversation: user talked about iris
+    sessions.addMessage("telegram:U1", "user", "check the roadmap on iris");
+    sessions.addMessage("telegram:U1", "assistant", "Here's the iris roadmap...");
+    sessions.addMessage("telegram:U1", "user", "what about tomorrow's plan");
+
+    // Simulate a completed task on iris
+    const taskId = queue.enqueue({
+      userId: "telegram:U1",
+      repo: "iris",
+      prompt: "check the roadmap",
+    });
+    queue.dequeue();
+    queue.complete(taskId, "Here's the roadmap...");
+
+    // Now a follow-up: "what about tomorrow" — no repo mentioned
+    const parsed = parseMessage("what about tomorrow's plan");
+    expect(parsed.type).toBe("free-form");
+    expect(parsed.repo).toBeUndefined(); // Router can't find repo in text
+
+    // But the last task was on iris
+    const recentTasks = queue.listByUser("telegram:U1", 5);
+    const lastRepo = recentTasks.find(t => t.status === "completed" || t.status === "failed")?.repo;
+    expect(lastRepo).toBe("iris");
+
+    // And the conversation history mentions iris
+    const history = sessions.getHistory("telegram:U1", 6);
+    expect(history.some(m => m.content.includes("iris"))).toBe(true);
+  });
+
+  it("explicit repo in message overrides last task repo", () => {
+    const db = new Database(":memory:");
+    db.run("PRAGMA journal_mode = WAL");
+    const queue = new TaskQueue(db);
+
+    // Last task was on iris
+    const taskId = queue.enqueue({
+      userId: "telegram:U1",
+      repo: "iris",
+      prompt: "check roadmap",
+    });
+    queue.dequeue();
+    queue.complete(taskId, "done");
+
+    // But new message explicitly says "on docs"
+    const parsed = parseMessage("check the tests on docs");
+    expect(parsed.repo).toBe("docs"); // Regex hint takes priority
+  });
+
+  it("lastRepo only considers completed/failed tasks, not pending", () => {
+    const db = new Database(":memory:");
+    db.run("PRAGMA journal_mode = WAL");
+    const queue = new TaskQueue(db);
+
+    // Completed task on iris
+    const task1 = queue.enqueue({
+      userId: "telegram:U1",
+      repo: "iris",
+      prompt: "check roadmap",
+    });
+    queue.dequeue();
+    queue.complete(task1, "done");
+
+    // Pending task on docs (enqueued but not completed)
+    queue.enqueue({
+      userId: "telegram:U1",
+      repo: "docs",
+      prompt: "pending work",
+    });
+
+    // lastRepo should be iris (completed), not docs (pending)
+    const recentTasks = queue.listByUser("telegram:U1", 5);
+    const lastRepo = recentTasks.find(t => t.status === "completed" || t.status === "failed")?.repo;
+    expect(lastRepo).toBe("iris");
+  });
+
+  it("LLM resolver prompt includes conversation history", () => {
+    const db = new Database(":memory:");
+    const sessions = new SessionStore(db);
+
+    sessions.addMessage("telegram:U1", "user", "check the roadmap on iris");
+    sessions.addMessage("telegram:U1", "assistant", "Here's the iris roadmap...");
+    sessions.addMessage("telegram:U1", "user", "what about tomorrow");
+
+    const history = sessions.getHistory("telegram:U1", 6);
+    const historyContext = history.length > 1
+      ? "Recent conversation:\n" + history.slice(0, -1).map(m => `${m.role}: ${m.content}`).join("\n") + "\n\n"
+      : "";
+    const resolvePrompt = `You are a repo-name resolver. ${historyContext}The user's latest message:\n"what about tomorrow"\n\nAvailable repos: iris, docs, my-app\n\nRespond with ONLY the repo name that best matches their request. Consider the conversation context if the current message doesn't mention a specific repo. Nothing else — just the exact repo name from the list. If you cannot determine which repo, respond with "UNKNOWN".`;
+
+    expect(resolvePrompt).toContain("Recent conversation:");
+    expect(resolvePrompt).toContain("check the roadmap on iris");
+    expect(resolvePrompt).toContain("Here's the iris roadmap");
+    expect(resolvePrompt).toContain("what about tomorrow");
+    expect(resolvePrompt).toContain("iris, docs, my-app");
+    expect(resolvePrompt).toContain("Consider the conversation context");
+  });
+});

package/src/handlers.ts

@@ -10,6 +10,7 @@ import type { ScheduleStore } from "./schedules";
 import type { RepoRegistry } from "./repo-registry";
 import type { IncomingMessage, EventAdapter, IncomingEvent } from "./adapters/types";
 import type { AgentRunner } from "./runner";
+import type { TraceStore } from "./trace";
 
 export interface HandlerDeps {
   config: Config;
@@ -17,6 +18,7 @@ export interface HandlerDeps {
   sessions: SessionStore;
   schedules: ScheduleStore;
   repoRegistry: RepoRegistry;
+  trace: TraceStore;
   pendingReplies: Map<string, IncomingMessage>;
   pendingEventReplies: Map<string, { adapter: EventAdapter; event: IncomingEvent }>;
   runningProcesses: Map<string, { abort: AbortController; task: Task }>;
@@ -147,6 +149,7 @@ async function handleHelp(msg: IncomingMessage, deps: HandlerDeps) {
     "• 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",
+    "• trace [task-id] — see what happened step by step",
     "• status / history / clear",
     "• <task> every day/weekday at <time> [on <repo>] — schedule a recurring task",
     "• list schedules — see your scheduled tasks",
@@ -240,6 +243,44 @@ async function handleRemoveSchedule(msg: IncomingMessage, args: Record<string, a
   deps.sessions.addMessage(msg.userId, "assistant", reply);
 }
 
+async function handleTrace(msg: IncomingMessage, args: Record<string, any>, deps: HandlerDeps) {
+  let taskId = args.taskId as string | undefined;
+
+  if (!taskId) {
+    const recent = deps.queue.listByUser(msg.userId, 1);
+    if (recent.length === 0) {
+      await msg.reply("No tasks found. Nothing to trace.");
+      return;
+    }
+    taskId = recent[0].id;
+  }
+
+  // Support prefix matching like cancel does
+  const task = deps.queue.get(taskId);
+  if (!task) {
+    await msg.reply(`No task found matching "${taskId}".`);
+    return;
+  }
+
+  const events = deps.trace.getByTask(task.id);
+  if (events.length === 0) {
+    const reason = deps.trace.isEnabled()
+      ? "No trace events recorded for this task."
+      : "Tracing is disabled. Set OVE_TRACE=true to enable.";
+    await msg.reply(reason);
+    return;
+  }
+
+  const lines = events.map((e) => {
+    const time = e.ts.slice(11, 19); // HH:MM:SS
+    const detail = e.detail ? ` — ${e.detail.slice(0, 120)}` : "";
+    return `${time} [${e.kind}] ${e.summary}${detail}`;
+  });
+
+  const reply = `Trace for ${task.id.slice(0, 7)} (${task.repo}):\n${lines.join("\n")}`;
+  await msg.reply(reply);
+}
+
 async function handleSchedule(msg: IncomingMessage, parsedRepo: string | undefined, deps: HandlerDeps) {
   await msg.updateStatus("Parsing your schedule...");
   const rawRepos = getUserRepos(deps.config, msg.userId);
@@ -374,24 +415,41 @@ async function handleTaskMessage(msg: IncomingMessage, parsed: ParsedMessage, de
         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)}`);
+        // Try last completed task's repo first (cheap)
+        const recentTasks = deps.queue.listByUser(msg.userId, 5);
+        const lastRepo = recentTasks.find(t => t.status === "completed" || t.status === "failed")?.repo;
+        if (lastRepo && repoNames.includes(lastRepo)) {
+          parsed.repo = lastRepo;
+          logger.info("repo resolved from recent task", { resolved: lastRepo, userText: parsed.rawText.slice(0, 80) });
+        } else {
+          // Resolve repo via a quick LLM call, then enqueue through the normal path
+          const repoList = repoNames.join(", ");
+          const history = deps.sessions.getHistory(msg.userId, 6);
+          const historyContext = history.length > 1
+            ? "Recent conversation:\n" + history.slice(0, -1).map(m => `${m.role}: ${m.content}`).join("\n") + "\n\n"
+            : "";
+          const resolvePrompt = `You are a repo-name resolver. ${historyContext}The user's latest message:\n"${parsed.rawText}"\n\nAvailable repos: ${repoList}\n\nRespond with ONLY the repo name that best matches their request. Consider the conversation context if the current message doesn't mention a specific repo. Nothing else — just the exact repo name from the list. If you cannot determine which repo, respond with "UNKNOWN".`;
+
+          await msg.updateStatus("Figuring out which repo...");
+          try {
+            const runner = deps.getRunner(deps.config.runner?.name);
+            const result = await runner.run(resolvePrompt, deps.config.reposDir, { maxTurns: 1 });
+            const resolved = result.output.trim().replace(/[`"']/g, "");
+
+            if (resolved === "UNKNOWN" || !repoNames.includes(resolved)) {
+              const reply = `Which repo? I see ${repoNames.length} repos. Some matches: ${repoNames.slice(0, 10).join(", ")}${repoNames.length > 10 ? "..." : ""}.\nSay it again with 'on <repo>'.`;
+              await msg.reply(reply);
+              deps.sessions.addMessage(msg.userId, "assistant", reply);
+              return;
+            }
+
+            parsed.repo = resolved;
+            logger.info("repo resolved via LLM", { resolved, userText: parsed.rawText.slice(0, 80) });
+          } catch (err) {
+            await msg.reply(`Couldn't figure out the repo: ${String(err).slice(0, 300)}`);
+            return;
+          }
         }
-        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`";
@@ -442,6 +500,7 @@ export function createMessageHandler(deps: HandlerDeps): (msg: IncomingMessage)
       "help": () => handleHelp(msg, deps),
       "list-tasks": () => handleListTasks(msg, deps),
       "cancel-task": () => handleCancelTask(msg, parsed.args, deps),
+      "trace": () => handleTrace(msg, parsed.args, deps),
       "list-schedules": () => handleListSchedules(msg, deps),
       "remove-schedule": () => handleRemoveSchedule(msg, parsed.args, deps),
       "schedule": () => handleSchedule(msg, parsed.repo, deps),

package/src/index.ts

@@ -18,6 +18,7 @@ import type { AgentRunner, RunOptions } from "./runner";
 import { logger } from "./logger";
 import { RepoRegistry, syncGitHub } from "./repo-registry";
 import { SessionStore } from "./sessions";
+import { TraceStore } from "./trace";
 import { startCronLoop } from "./cron";
 import { ScheduleStore } from "./schedules";
 import { createMessageHandler, createEventHandler } from "./handlers";
@@ -30,6 +31,7 @@ db.run("PRAGMA journal_mode = WAL");
 const queue = new TaskQueue(db);
 const repos = new RepoManager(config.reposDir);
 const sessions = new SessionStore(db);
+const trace = new TraceStore(db);
 const schedules = new ScheduleStore(db);
 const repoRegistry = new RepoRegistry(db);
 
@@ -113,8 +115,11 @@ if (process.env.SLACK_BOT_TOKEN && process.env.SLACK_APP_TOKEN) {
 }
 
 if (process.env.WHATSAPP_ENABLED === "true") {
+  const allowedChats = process.env.WHATSAPP_ALLOWED_CHATS
+    ?.split(",").map((s) => s.trim()).filter(Boolean);
   adapters.push(new WhatsAppAdapter({
     phoneNumber: process.env.WHATSAPP_PHONE,
+    allowedChats,
   }));
 }
 
@@ -132,7 +137,10 @@ const eventAdapters: EventAdapter[] = [];
 if (process.env.HTTP_API_PORT) {
   const httpAdapter = new HttpApiAdapter(
     parseInt(process.env.HTTP_API_PORT),
-    process.env.HTTP_API_KEY || crypto.randomUUID()
+    process.env.HTTP_API_KEY || crypto.randomUUID(),
+    trace,
+    queue,
+    sessions
   );
   eventAdapters.push(httpAdapter);
 }
@@ -152,12 +160,14 @@ if (process.env.CLI_MODE === "true" || (adapters.length === 0 && eventAdapters.l
 
 // Main
 async function main() {
+  // Capture stale tasks before resetting so we can notify users
+  const staleTasks = queue.listActive().filter((t) => t.status === "running");
   const staleCount = queue.resetStale();
   if (staleCount > 0) {
     logger.info("reset stale tasks", { count: staleCount });
   }
 
-  logger.info("ove starting", { chatAdapters: adapters.length, eventAdapters: eventAdapters.length, runner: config.runner?.name || "claude" });
+  logger.info("ove starting", { chatAdapters: adapters.length, eventAdapters: eventAdapters.length, runner: config.runner?.name || "claude", tracing: trace.isEnabled() });
 
   startGitHubSync().catch((err) =>
     logger.warn("initial github sync failed", { error: String(err) })
@@ -169,6 +179,7 @@ async function main() {
     sessions,
     schedules,
     repoRegistry,
+    trace,
     pendingReplies,
     pendingEventReplies,
     runningProcesses,
@@ -183,6 +194,7 @@ async function main() {
     sessions,
     schedules,
     repoRegistry,
+    trace,
     pendingReplies,
     pendingEventReplies,
     runningProcesses,
@@ -196,6 +208,11 @@ async function main() {
   }
 
   for (const ea of eventAdapters) {
+    // Wire up chat handler for HTTP adapter so web UI gets full chat features
+    if (ea instanceof HttpApiAdapter) {
+      ea.setMessageHandler(handleMessage);
+      ea.setAdapters(adapters, eventAdapters);
+    }
     await ea.start((event) => handleEvent(event, ea));
   }
 
@@ -215,6 +232,7 @@ async function main() {
         userId: cronTask.userId,
         repo: cronTask.repo,
         prompt: buildCronPrompt(cronTask.prompt),
+        taskType: "cron",
       });
     }
   );
@@ -225,15 +243,30 @@ async function main() {
     queue,
     repos,
     sessions,
+    adapters,
     pendingReplies,
     pendingEventReplies,
     runningProcesses,
     getRunnerForRepo,
     getRunnerOptsForRepo,
     getRepoInfo,
+    trace,
   });
   worker.start();
 
+  // Notify users whose tasks were interrupted by restart
+  if (staleTasks.length > 0) {
+    for (const task of staleTasks) {
+      const platform = task.userId.split(":")[0];
+      const adapter = adapters.find((a) => a.constructor.name.toLowerCase().includes(platform));
+      if (adapter?.sendToUser) {
+        adapter.sendToUser(task.userId, `Your task was interrupted by a restart: "${task.prompt.slice(0, 100)}". Please re-submit if needed.`).catch((err) =>
+          logger.warn("failed to notify user of interrupted task", { userId: task.userId, error: String(err) })
+        );
+      }
+    }
+  }
+
   logger.info("ove ready");
 
   async function shutdown() {

package/src/queue.ts

@@ -143,6 +143,28 @@ export class TaskQueue {
     return result.changes > 0;
   }
 
+  listRecentFailed(limit: number = 20): Task[] {
+    const rows = this.db
+      .query(
+        `SELECT * FROM tasks WHERE status = 'failed' ORDER BY completed_at DESC LIMIT ?`
+      )
+      .all(limit) as TaskRow[];
+    return rows.map((r) => this.rowToTask(r));
+  }
+
+  listRecent(limit: number = 20, status?: string): Task[] {
+    let sql = `SELECT * FROM tasks`;
+    const params: (string | number)[] = [];
+    if (status) {
+      sql += ` WHERE status = ?`;
+      params.push(status);
+    }
+    sql += ` ORDER BY created_at DESC LIMIT ?`;
+    params.push(limit);
+    const rows = this.db.query(sql).all(...params) as TaskRow[];
+    return rows.map((r) => this.rowToTask(r));
+  }
+
   resetStale(): number {
     const result = this.db.run(
       `UPDATE tasks SET status = 'failed', result = 'Interrupted — process restarted', completed_at = ? WHERE status = 'running'`,