heyhank 0.1.0 → 0.2.0

package/server/routes/assistant-routes.ts

@@ -3,8 +3,61 @@
 
 import type { Hono } from "hono";
 import * as store from "../assistant-store.js";
+import * as calendarService from "../calendar-service.js";
+import * as emailService from "../email-service.js";
 
 export function registerAssistantRoutes(api: Hono): void {
+  // ─── Daily Briefing ──────────────────────────────────────────────────
+
+  api.get("/assistant/briefing", async (c) => {
+    const dateStr = (c.req.query("date") as string) || new Date().toISOString().slice(0, 10);
+    const today = dateStr;
+    const tomorrowDate = new Date(dateStr);
+    tomorrowDate.setDate(tomorrowDate.getDate() + 1);
+    const tomorrow = tomorrowDate.toISOString().slice(0, 10);
+
+    let emailSummary: Array<{ accountName: string; email: string; unread: number }> = [];
+    let totalUnread = 0;
+    try {
+      emailSummary = await emailService.getUnreadSummary();
+      totalUnread = emailSummary.reduce((s, a) => s + a.unread, 0);
+    } catch {}
+
+    let todayEvents: Array<Record<string, unknown>> = [];
+    try {
+      const calAccounts = calendarService.loadAccounts();
+      for (const acc of calAccounts) {
+        const events = await calendarService.listEvents(acc, { from: today, to: tomorrow });
+        todayEvents.push(...events.map((e) => ({ ...e, account: acc.name })));
+      }
+    } catch {}
+
+    const allTodos = store.listTodos({ done: false });
+    const overdueTodos = allTodos.filter((t) => t.dueDate && t.dueDate < today);
+    const dueTodayTodos = allTodos.filter((t) => t.dueDate === today);
+
+    const delegations = store.listDelegations();
+
+    const projectTodos = store.listTodos();
+    const projects: Record<string, { total: number; done: number; open: number }> = {};
+    for (const t of projectTodos) {
+      if (!t.project) continue;
+      if (!projects[t.project]) projects[t.project] = { total: 0, done: 0, open: 0 };
+      projects[t.project].total++;
+      if (t.done) projects[t.project].done++;
+      else projects[t.project].open++;
+    }
+
+    return c.json({
+      date: today,
+      email: { accounts: emailSummary, totalUnread },
+      calendar: { events: todayEvents, count: todayEvents.length },
+      todos: { open: allTodos.length, overdue: overdueTodos.length, dueToday: dueTodayTodos.length },
+      delegations: { count: delegations.length },
+      projects: Object.entries(projects).map(([name, p]) => ({ name, ...p })),
+    });
+  });
+
   // ─── Todos ──────────────────────────────────────────────────────────
 
   api.get("/assistant/todos", (c) => {
@@ -19,15 +72,21 @@ export function registerAssistantRoutes(api: Hono): void {
   });
 
   api.post("/assistant/todos", async (c) => {
-    const body = await c.req.json<{ text: string; priority?: string; category?: string }>();
+    const body = await c.req.json<{ text: string; priority?: string; category?: string; delegatedTo?: string; dueDate?: string; followUpDate?: string; project?: string }>();
     if (!body.text) return c.json({ error: "text is required" }, 400);
-    const todo = store.addTodo(body.text, body.priority, body.category);
+    const extra = {
+      delegatedTo: body.delegatedTo,
+      dueDate: body.dueDate,
+      followUpDate: body.followUpDate,
+      project: body.project,
+    };
+    const todo = store.addTodo(body.text, body.priority, body.category, extra);
     return c.json(todo);
   });
 
   api.patch("/assistant/todos/:id", async (c) => {
     const id = c.req.param("id");
-    const body = await c.req.json<{ text?: string; priority?: string; category?: string; done?: boolean }>();
+    const body = await c.req.json<{ text?: string; priority?: string; category?: string; done?: boolean; delegatedTo?: string; dueDate?: string; followUpDate?: string; project?: string }>();
     if (body.done === true) {
       const todo = store.completeTodo(id);
       if (!todo) return c.json({ error: "not found" }, 404);
@@ -43,6 +102,13 @@ export function registerAssistantRoutes(api: Hono): void {
     return c.json({ ok });
   });
 
+  // ─── Delegations ──────────────────────────────────────────────────────
+
+  api.get("/assistant/delegations", (c) => {
+    const person = c.req.query("person");
+    return c.json({ delegations: store.listDelegations(person) });
+  });
+
   // ─── Notes ──────────────────────────────────────────────────────────
 
   api.get("/assistant/notes", (c) => {
@@ -80,11 +146,138 @@ export function registerAssistantRoutes(api: Hono): void {
     const body = await c.req.json<{ text: string; triggerAt: string }>();
     if (!body.text || !body.triggerAt) return c.json({ error: "text and triggerAt required" }, 400);
     const reminder = store.addReminder(body.text, body.triggerAt);
+    // Try to create a calendar event for the reminder
+    try {
+      const accounts = calendarService.loadAccounts();
+      if (accounts.length > 0) {
+        const account = accounts[0]; // Use first calendar account
+        const triggerDate = new Date(body.triggerAt);
+        const endDate = new Date(triggerDate.getTime() + 15 * 60 * 1000); // 15 min event
+        const result = await calendarService.createEvent(account, {
+          summary: `Reminder: ${body.text}`,
+          description: body.text,
+          start: triggerDate.toISOString(),
+          end: endDate.toISOString(),
+          alarm: 0, // alarm at event time
+        });
+        // Save calendar UID back to reminder
+        store.updateReminder(reminder.id, { calendarEventUid: result.uid });
+        reminder.calendarEventUid = result.uid;
+      }
+    } catch (err) {
+      // Calendar integration is best-effort — don't fail the reminder creation
+      console.warn("[assistant] Failed to create calendar event for reminder:", err instanceof Error ? err.message : err);
+    }
     return c.json(reminder);
   });
 
-  api.delete("/assistant/reminders/:id", (c) => {
-    const ok = store.deleteReminder(c.req.param("id"));
+  api.patch("/assistant/reminders/:id", async (c) => {
+    const id = c.req.param("id");
+    const body = await c.req.json<{ text?: string; triggerAt?: string }>();
+    if (!body.text && !body.triggerAt) return c.json({ error: "Nothing to update" }, 400);
+    const updated = store.updateReminder(id, body);
+    if (!updated) return c.json({ error: "Not found" }, 404);
+
+    // If the reminder has a calendar event, try to update it
+    if (updated.calendarEventUid && body.triggerAt) {
+      try {
+        const accounts = calendarService.loadAccounts();
+        if (accounts.length > 0) {
+          // Delete old event and create new one (simpler than CalDAV update)
+          await calendarService.deleteEvent(accounts[0], updated.calendarEventUid).catch(() => {});
+          const triggerDate = new Date(body.triggerAt || updated.triggerAt);
+          const endDate = new Date(triggerDate.getTime() + 15 * 60 * 1000);
+          const result = await calendarService.createEvent(accounts[0], {
+            summary: `Reminder: ${updated.text}`,
+            description: updated.text,
+            start: triggerDate.toISOString(),
+            end: endDate.toISOString(),
+            alarm: 0,
+          });
+          store.updateReminder(id, { calendarEventUid: result.uid });
+          updated.calendarEventUid = result.uid;
+        }
+      } catch (err) {
+        console.warn("[assistant] Failed to update calendar event:", err instanceof Error ? err.message : err);
+      }
+    }
+
+    return c.json(updated);
+  });
+
+  api.delete("/assistant/reminders/:id", async (c) => {
+    const id = c.req.param("id");
+    // Try to remove associated calendar event
+    const reminders = store.listReminders(true);
+    const reminder = reminders.find(r => r.id === id);
+    if (reminder?.calendarEventUid) {
+      try {
+        const accounts = calendarService.loadAccounts();
+        if (accounts.length > 0) {
+          await calendarService.deleteEvent(accounts[0], reminder.calendarEventUid);
+        }
+      } catch { /* best-effort */ }
+    }
+    const ok = store.deleteReminder(id);
+    return c.json({ ok });
+  });
+
+  // ─── Contacts ──────────────────────────────────────────────────────────
+
+  api.get("/assistant/contacts", (c) => {
+    const search = c.req.query("search");
+    return c.json({ contacts: store.listContacts(search) });
+  });
+
+  api.post("/assistant/contacts", async (c) => {
+    const body = await c.req.json<{ name: string; company?: string; email?: string; phone?: string; notes?: string; tags?: string[] }>();
+    if (!body.name) return c.json({ error: "name is required" }, 400);
+    const contact = store.addContact(body.name, body.company, body.email, body.phone, body.notes, body.tags);
+    return c.json(contact);
+  });
+
+  api.get("/assistant/contacts/:id", (c) => {
+    const contact = store.getContact(c.req.param("id"));
+    if (!contact) return c.json({ error: "not found" }, 404);
+    return c.json(contact);
+  });
+
+  api.patch("/assistant/contacts/:id", async (c) => {
+    const body = await c.req.json<{ name?: string; company?: string; email?: string; phone?: string; notes?: string; tags?: string[] }>();
+    const contact = store.updateContact(c.req.param("id"), body);
+    if (!contact) return c.json({ error: "not found" }, 404);
+    return c.json(contact);
+  });
+
+  api.delete("/assistant/contacts/:id", (c) => {
+    const ok = store.deleteContact(c.req.param("id"));
+    return c.json({ ok });
+  });
+
+  api.post("/assistant/contacts/:id/interactions", async (c) => {
+    const body = await c.req.json<{ type: "call" | "email" | "meeting" | "note"; summary: string }>();
+    if (!body.type || !body.summary) return c.json({ error: "type and summary are required" }, 400);
+    const contact = store.logInteraction(c.req.param("id"), { type: body.type, summary: body.summary });
+    if (!contact) return c.json({ error: "not found" }, 404);
+    return c.json(contact);
+  });
+
+  // ─── Decisions ─────────────────────────────────────────────────────────
+
+  api.get("/assistant/decisions", (c) => {
+    const search = c.req.query("search");
+    return c.json({ decisions: store.listDecisions(search) });
+  });
+
+  api.post("/assistant/decisions", async (c) => {
+    const body = await c.req.json<{ title: string; context: string; decision: string; alternatives?: string[]; reasoning?: string; tags?: string[] }>();
+    if (!body.title || !body.context || !body.decision) return c.json({ error: "title, context and decision are required" }, 400);
+    const decision = store.addDecision(body.title, body.context, body.decision, body.alternatives, body.reasoning, body.tags);
+    return c.json(decision);
+  });
+
+  api.delete("/assistant/decisions/:id", (c) => {
+    const ok = store.deleteDecision(c.req.param("id"));
     return c.json({ ok });
   });
 }

package/server/routes/ceo-finance-kpi-routes.ts

@@ -0,0 +1,167 @@
+import { Hono } from "hono";
+import * as financeStore from "../ceo/finance-store.js";
+import * as kpiStore from "../ceo/kpi-store.js";
+
+export function registerCeoFinanceKpiRoutes(api: Hono) {
+  // === INVOICES ===
+  api.get("/assistant/invoices", (c) => {
+    const status = c.req.query("status") || undefined;
+    const start = c.req.query("start") || undefined;
+    const end = c.req.query("end") || undefined;
+    return c.json({ invoices: financeStore.listInvoices(status, start, end) });
+  });
+
+  api.post("/assistant/invoices", async (c) => {
+    const body = await c.req.json();
+    if (!body.clientName || !body.items?.length) {
+      return c.json({ error: "clientName and items are required" }, 400);
+    }
+    const invoice = financeStore.createInvoice(body.clientName, body.items, {
+      clientEmail: body.clientEmail,
+      clientAddress: body.clientAddress,
+      taxRate: body.taxRate,
+      currency: body.currency,
+      dueDate: body.dueDate,
+      notes: body.notes
+    });
+    return c.json(invoice, 201);
+  });
+
+  api.get("/assistant/invoices/:id", (c) => {
+    const invoice = financeStore.getInvoice(c.req.param("id"));
+    if (!invoice) return c.json({ error: "not found" }, 404);
+    return c.json(invoice);
+  });
+
+  api.patch("/assistant/invoices/:id", async (c) => {
+    const body = await c.req.json();
+    const invoice = financeStore.updateInvoice(c.req.param("id"), body);
+    if (!invoice) return c.json({ error: "not found" }, 404);
+    return c.json(invoice);
+  });
+
+  api.post("/assistant/invoices/:id/paid", (c) => {
+    const invoice = financeStore.markPaid(c.req.param("id"));
+    if (!invoice) return c.json({ error: "not found" }, 404);
+    return c.json(invoice);
+  });
+
+  api.delete("/assistant/invoices/:id", (c) => {
+    const ok = financeStore.deleteInvoice(c.req.param("id"));
+    if (!ok) return c.json({ error: "not found" }, 404);
+    return c.json({ success: true });
+  });
+
+  // === EXPENSES ===
+  api.get("/assistant/expenses", (c) => {
+    const category = c.req.query("category") || undefined;
+    const start = c.req.query("start") || undefined;
+    const end = c.req.query("end") || undefined;
+    return c.json({ expenses: financeStore.listExpenses(category, start, end) });
+  });
+
+  api.post("/assistant/expenses", async (c) => {
+    const body = await c.req.json();
+    if (!body.description || body.amount === undefined || !body.category) {
+      return c.json({ error: "description, amount, and category are required" }, 400);
+    }
+    const expense = financeStore.logExpense(body.description, body.amount, body.category, {
+      currency: body.currency,
+      date: body.date,
+      project: body.project,
+      vendor: body.vendor,
+      recurring: body.recurring,
+      notes: body.notes
+    });
+    return c.json(expense, 201);
+  });
+
+  api.delete("/assistant/expenses/:id", (c) => {
+    const ok = financeStore.deleteExpense(c.req.param("id"));
+    if (!ok) return c.json({ error: "not found" }, 404);
+    return c.json({ success: true });
+  });
+
+  api.get("/assistant/expenses/categories", (c) => {
+    return c.json({ categories: financeStore.listExpenseCategories() });
+  });
+
+  // === FINANCIAL SUMMARY ===
+  api.get("/assistant/finance/summary", (c) => {
+    const period = (c.req.query("period") || "month") as "month" | "quarter" | "year" | "custom";
+    const start = c.req.query("start") || undefined;
+    const end = c.req.query("end") || undefined;
+    return c.json(financeStore.getFinancialSummary(period, start, end));
+  });
+
+  api.get("/assistant/finance/settings", (c) => {
+    return c.json(financeStore.getFinanceSettings());
+  });
+
+  api.patch("/assistant/finance/settings", async (c) => {
+    const body = await c.req.json();
+    return c.json(financeStore.updateFinanceSettings(body));
+  });
+
+  // === KPI ===
+  api.get("/assistant/kpis", (c) => {
+    const category = c.req.query("category") || undefined;
+    return c.json({ kpis: kpiStore.listKPIs(category) });
+  });
+
+  api.get("/assistant/kpis/dashboard", (c) => {
+    return c.json(kpiStore.getDashboard());
+  });
+
+  api.get("/assistant/kpis/categories", (c) => {
+    return c.json({ categories: kpiStore.listCategories() });
+  });
+
+  api.post("/assistant/kpis", async (c) => {
+    const body = await c.req.json();
+    if (!body.name || !body.unit || !body.category) {
+      return c.json({ error: "name, unit, and category are required" }, 400);
+    }
+    const kpi = kpiStore.defineKPI(body.name, body.unit, body.category, {
+      description: body.description,
+      target: body.target,
+      direction: body.direction,
+      warningThreshold: body.warningThreshold,
+      criticalThreshold: body.criticalThreshold
+    });
+    return c.json(kpi, 201);
+  });
+
+  api.get("/assistant/kpis/:id", (c) => {
+    const kpi = kpiStore.getKPI(c.req.param("id"));
+    if (!kpi) return c.json({ error: "not found" }, 404);
+    return c.json(kpi);
+  });
+
+  api.patch("/assistant/kpis/:id", async (c) => {
+    const body = await c.req.json();
+    const kpi = kpiStore.updateKPI(c.req.param("id"), body);
+    if (!kpi) return c.json({ error: "not found" }, 404);
+    return c.json(kpi);
+  });
+
+  api.post("/assistant/kpis/:id/record", async (c) => {
+    const body = await c.req.json();
+    if (body.value === undefined) return c.json({ error: "value is required" }, 400);
+    const kpi = kpiStore.recordValue(c.req.param("id"), body.value, body.date, body.note);
+    if (!kpi) return c.json({ error: "not found" }, 404);
+    return c.json(kpi);
+  });
+
+  api.get("/assistant/kpis/:id/history", (c) => {
+    const period = c.req.query("period") as "week" | "month" | "quarter" | "year" | undefined;
+    const history = kpiStore.getKPIHistory(c.req.param("id"), period);
+    return c.json({ history });
+  });
+
+  api.delete("/assistant/kpis/:id", (c) => {
+    const ok = kpiStore.deleteKPI(c.req.param("id"));
+    if (!ok) return c.json({ error: "not found" }, 404);
+    return c.json({ success: true });
+  });
+}

package/server/routes/ceo-news-time-routes.ts

@@ -0,0 +1,137 @@
+import { Hono } from "hono";
+import * as newsStore from "../ceo/news-store.js";
+import * as timeStore from "../ceo/time-tracking-store.js";
+
+export function registerCeoNewsTimeRoutes(api: Hono) {
+  // === NEWS SOURCES ===
+  api.get("/assistant/news/sources", (c) => {
+    return c.json({ sources: newsStore.listSources() });
+  });
+
+  api.post("/assistant/news/sources", async (c) => {
+    const body = await c.req.json();
+    if (!body.name || !body.type || !body.category) {
+      return c.json({ error: "name, type, and category are required" }, 400);
+    }
+    const source = newsStore.addSource(body.name, body.type, body.category, body.url, body.keywords, body.checkInterval);
+    return c.json(source, 201);
+  });
+
+  api.patch("/assistant/news/sources/:id", async (c) => {
+    const body = await c.req.json();
+    const source = newsStore.updateSource(c.req.param("id"), body);
+    if (!source) return c.json({ error: "not found" }, 404);
+    return c.json(source);
+  });
+
+  api.delete("/assistant/news/sources/:id", (c) => {
+    const ok = newsStore.deleteSource(c.req.param("id"));
+    if (!ok) return c.json({ error: "not found" }, 404);
+    return c.json({ success: true });
+  });
+
+  // === NEWS ITEMS ===
+  api.get("/assistant/news", (c) => {
+    const category = c.req.query("category") || undefined;
+    const unreadOnly = c.req.query("unread") === "true";
+    const savedOnly = c.req.query("saved") === "true";
+    const limit = parseInt(c.req.query("limit") || "50");
+    return c.json({ items: newsStore.listNews(category, unreadOnly, savedOnly, limit) });
+  });
+
+  api.get("/assistant/news/stats", (c) => {
+    return c.json(newsStore.getNewsStats());
+  });
+
+  api.get("/assistant/news/search", (c) => {
+    const query = c.req.query("q") || "";
+    return c.json({ items: newsStore.searchNews(query) });
+  });
+
+  api.post("/assistant/news/items", async (c) => {
+    const body = await c.req.json();
+    if (!body.sourceId || !body.title || !body.summary || !body.category) {
+      return c.json({ error: "sourceId, title, summary, and category are required" }, 400);
+    }
+    const item = newsStore.addNewsItem(body.sourceId, body.sourceName || "", body.title, body.summary, body.category, body.url, body.relevance);
+    return c.json(item, 201);
+  });
+
+  api.patch("/assistant/news/:id/read", (c) => {
+    const ok = newsStore.markRead(c.req.param("id"));
+    if (!ok) return c.json({ error: "not found" }, 404);
+    return c.json({ success: true });
+  });
+
+  api.post("/assistant/news/mark-all-read", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const count = newsStore.markAllRead(body.category);
+    return c.json({ markedRead: count });
+  });
+
+  api.patch("/assistant/news/:id/save", (c) => {
+    const item = newsStore.toggleSaved(c.req.param("id"));
+    if (!item) return c.json({ error: "not found" }, 404);
+    return c.json(item);
+  });
+
+  // === TIME TRACKING ===
+  api.get("/assistant/time/timer", (c) => {
+    const timer = timeStore.getActiveTimer();
+    return c.json({ timer });
+  });
+
+  api.post("/assistant/time/timer/start", async (c) => {
+    const body = await c.req.json();
+    if (!body.task) return c.json({ error: "task is required" }, 400);
+    const timer = timeStore.startTimer(body.task, body.project, body.category);
+    return c.json(timer, 201);
+  });
+
+  api.post("/assistant/time/timer/stop", async (c) => {
+    const body = await c.req.json().catch(() => ({}));
+    const entry = timeStore.stopTimer(body.notes);
+    if (!entry) return c.json({ error: "no active timer" }, 400);
+    return c.json(entry);
+  });
+
+  api.post("/assistant/time/log", async (c) => {
+    const body = await c.req.json();
+    if (!body.task || body.duration === undefined) {
+      return c.json({ error: "task and duration are required" }, 400);
+    }
+    const entry = timeStore.logTime(body.task, body.duration, body.project, body.category, body.notes, body.date);
+    return c.json(entry, 201);
+  });
+
+  api.get("/assistant/time/entries", (c) => {
+    const startDate = c.req.query("start") || undefined;
+    const endDate = c.req.query("end") || undefined;
+    const project = c.req.query("project") || undefined;
+    return c.json({ entries: timeStore.listEntries(startDate, endDate, project) });
+  });
+
+  api.get("/assistant/time/report", (c) => {
+    const period = (c.req.query("period") || "week") as "today" | "week" | "month" | "custom";
+    const start = c.req.query("start") || undefined;
+    const end = c.req.query("end") || undefined;
+    return c.json(timeStore.getReport(period, start, end));
+  });
+
+  api.get("/assistant/time/projects", (c) => {
+    return c.json({ projects: timeStore.listProjects() });
+  });
+
+  api.delete("/assistant/time/entries/:id", (c) => {
+    const ok = timeStore.deleteEntry(c.req.param("id"));
+    if (!ok) return c.json({ error: "not found" }, 404);
+    return c.json({ success: true });
+  });
+
+  api.patch("/assistant/time/entries/:id", async (c) => {
+    const body = await c.req.json();
+    const entry = timeStore.updateEntry(c.req.param("id"), body);
+    if (!entry) return c.json({ error: "not found" }, 404);
+    return c.json(entry);
+  });
+}

package/server/routes/ceo-routes.ts

@@ -0,0 +1,99 @@
+import { Hono } from "hono";
+import * as docStore from "../ceo/document-store.js";
+import * as templateStore from "../ceo/template-store.js";
+
+export function registerCeoDocumentRoutes(api: Hono) {
+  // Documents
+  api.get("/assistant/documents", (c) => {
+    const folder = c.req.query("folder") || undefined;
+    const tag = c.req.query("tag") || undefined;
+    return c.json({ documents: docStore.listDocuments(folder, tag) });
+  });
+
+  api.post("/assistant/documents", async (c) => {
+    const body = await c.req.json();
+    if (!body.title || !body.content || !body.fileType) {
+      return c.json({ error: "title, content, and fileType are required" }, 400);
+    }
+    const doc = docStore.addDocument(body.title, body.content, body.fileType, body.folder, body.tags, body.summary);
+    return c.json(doc, 201);
+  });
+
+  api.get("/assistant/documents/search", (c) => {
+    const query = c.req.query("q") || "";
+    return c.json({ documents: docStore.searchDocuments(query) });
+  });
+
+  api.get("/assistant/documents/folders", (c) => {
+    return c.json({ folders: docStore.listFolders() });
+  });
+
+  api.get("/assistant/documents/:id", (c) => {
+    const result = docStore.getDocument(c.req.param("id"));
+    if (!result) return c.json({ error: "not found" }, 404);
+    return c.json(result);
+  });
+
+  api.patch("/assistant/documents/:id", async (c) => {
+    const body = await c.req.json();
+    const doc = docStore.updateDocument(c.req.param("id"), body);
+    if (!doc) return c.json({ error: "not found" }, 404);
+    return c.json(doc);
+  });
+
+  api.delete("/assistant/documents/:id", (c) => {
+    const ok = docStore.deleteDocument(c.req.param("id"));
+    if (!ok) return c.json({ error: "not found" }, 404);
+    return c.json({ success: true });
+  });
+
+  // Templates
+  api.get("/assistant/templates", (c) => {
+    const category = c.req.query("category") || undefined;
+    return c.json({ templates: templateStore.listTemplates(category) });
+  });
+
+  api.post("/assistant/templates", async (c) => {
+    const body = await c.req.json();
+    if (!body.name || !body.content || !body.category) {
+      return c.json({ error: "name, content, and category are required" }, 400);
+    }
+    const tpl = templateStore.createTemplate(body.name, body.content, body.category, body.variables, body.tags);
+    return c.json(tpl, 201);
+  });
+
+  api.get("/assistant/templates/search", (c) => {
+    const query = c.req.query("q") || "";
+    return c.json({ templates: templateStore.searchTemplates(query) });
+  });
+
+  api.get("/assistant/templates/categories", (c) => {
+    return c.json({ categories: templateStore.listCategories() });
+  });
+
+  api.get("/assistant/templates/:id", (c) => {
+    const tpl = templateStore.getTemplate(c.req.param("id"));
+    if (!tpl) return c.json({ error: "not found" }, 404);
+    return c.json(tpl);
+  });
+
+  api.patch("/assistant/templates/:id", async (c) => {
+    const body = await c.req.json();
+    const tpl = templateStore.updateTemplate(c.req.param("id"), body);
+    if (!tpl) return c.json({ error: "not found" }, 404);
+    return c.json(tpl);
+  });
+
+  api.delete("/assistant/templates/:id", (c) => {
+    const ok = templateStore.deleteTemplate(c.req.param("id"));
+    if (!ok) return c.json({ error: "not found" }, 404);
+    return c.json({ success: true });
+  });
+
+  api.post("/assistant/templates/:id/use", async (c) => {
+    const body = await c.req.json();
+    const result = templateStore.useTemplate(c.req.param("id"), body.variables || {});
+    if (!result) return c.json({ error: "not found" }, 404);
+    return c.json(result);
+  });
+}