heyhank 0.1.0 → 0.3.0

package/server/agent-executor.ts

@@ -18,11 +18,27 @@ const CLI_CONNECT_TIMEOUT_MS = 30_000;
 /** Poll interval when waiting for CLI connection */
 const CLI_CONNECT_POLL_MS = 500;
 
+/** Skill-aware preamble for Claude agents (see skillRoutingEnabled below). */
+const SKILL_ROUTING_PREAMBLE = [
+  "[Skill-aware mode]",
+  "You have access to user-installed Claude Code skills via the Skill tool. Skills are structured multi-stage workflows for specific tasks (content plans, post writing, audits, code review, etc.) — their descriptions are listed in your system context.",
+  "",
+  "BEFORE following the specialized instructions below, check whether the user's request matches a skill's description. If yes, invoke that skill via the Skill tool instead of executing custom logic.",
+  "",
+  "The specialized instructions below apply when no skill is a better fit.",
+  "",
+  "---",
+  "",
+  "",
+].join("\n");
+
+
 export interface ExecuteAgentOptions {
   force?: boolean;
   triggerType?: "manual" | "webhook" | "schedule";
   additionalEnv?: Record<string, string>;
   systemPrompt?: string;
+  cwdOverride?: string;
 }
 
 export class AgentExecutor {
@@ -155,7 +171,7 @@ export class AgentExecutor {
       }
 
       // Resolve working directory
-      let cwd = agent.cwd;
+      let cwd = opts?.cwdOverride || agent.cwd;
       if (cwd === "temp" || !cwd) {
         cwd = mkdtempSync(join(tmpdir(), `heyhank-agent-${agent.id}-`));
       }
@@ -170,12 +186,24 @@ export class AgentExecutor {
           `but agent sessions always run with bypassPermissions`,
         );
       }
+      // Skill-aware routing: when enabled (default for Claude backends),
+      // ensure the `Skill` tool is in allowedTools so the agent can invoke
+      // any user-installed skill from ~/.claude/skills/ when its description
+      // matches the user's request.
+      const skillRoutingEnabled = agent.backendType === "claude" && agent.skillRouting !== false;
+      let effectiveAllowedTools = agent.allowedTools;
+      if (skillRoutingEnabled && Array.isArray(agent.allowedTools) && agent.allowedTools.length > 0) {
+        if (!agent.allowedTools.includes("Skill")) {
+          effectiveAllowedTools = [...agent.allowedTools, "Skill"];
+        }
+      }
+
       const sessionInfo = this.launcher.launch({
         model: agent.model,
         permissionMode: "bypassPermissions",
         cwd,
         env: envVars,
-        allowedTools: agent.allowedTools,
+        allowedTools: effectiveAllowedTools,
         backendType: agent.backendType,
         codexInternetAccess: agent.backendType === "codex" ? (agent.codexInternetAccess ?? true) : undefined,
         codexSandbox: agent.backendType === "codex"
@@ -220,6 +248,13 @@ export class AgentExecutor {
         resolvedPrompt = resolvedPrompt.replace(/\{\{input\}\}/g, "");
       }
 
+      // Skill-aware preamble: routes attention to matching skills before
+      // following specialized instructions. Skill descriptions are already
+      // in the CLI system context; this just teaches the agent to consult them.
+      if (skillRoutingEnabled) {
+        resolvedPrompt = SKILL_ROUTING_PREAMBLE + resolvedPrompt;
+      }
+
       // Send the prompt with agent prefix for traceability
       const fullPrompt = `[agent:${agent.id} ${agent.name}]\n\n${resolvedPrompt}`;
       this.wsBridge.injectUserMessage(sessionInfo.sessionId, fullPrompt);
@@ -316,6 +351,71 @@ export class AgentExecutor {
     return this.executionStore.list(opts);
   }
 
+  /**
+   * Cancel a running execution. Marks the in-memory + persisted record as
+   * completed (success=false). Returns true if a matching in-memory execution
+   * was found and updated, false if only the on-disk record was touched (e.g.
+   * for zombie sessions whose CLI process is long gone).
+   */
+  cancelExecution(sessionId: string, reason = "Stopped by user"): boolean {
+    for (const [, execs] of this.executions) {
+      const exec = execs.find((e) => e.sessionId === sessionId && !e.completedAt);
+      if (exec) {
+        exec.completedAt = Date.now();
+        exec.success = false;
+        exec.error = exec.error || reason;
+        this.executionStore.update(sessionId, {
+          completedAt: exec.completedAt,
+          success: exec.success,
+          error: exec.error,
+        });
+        return true;
+      }
+    }
+    // Fallback: touch the on-disk record directly (zombie cleanup).
+    this.executionStore.update(sessionId, {
+      completedAt: Date.now(),
+      success: false,
+      error: reason,
+    });
+    return false;
+  }
+
+  /**
+   * Permanently delete execution records (single or bulk). Filters by status
+   * if provided, or by an explicit list of sessionIds. Returns the count of
+   * removed records. Refuses to delete records that are still running.
+   */
+  deleteExecutions(opts: { sessionIds?: string[]; status?: "success" | "error" }): number {
+    let targets: string[] = [];
+
+    if (opts.sessionIds && opts.sessionIds.length > 0) {
+      // Filter out running ones — caller must cancel first.
+      const all = this.executionStore.list({ limit: 10000 }).executions;
+      const byId = new Map(all.map((e) => [e.sessionId, e] as const));
+      for (const sid of opts.sessionIds) {
+        const exec = byId.get(sid);
+        if (!exec || exec.completedAt) targets.push(sid);
+      }
+    } else if (opts.status) {
+      const matching = this.executionStore.list({ status: opts.status, limit: 10000 }).executions;
+      targets = matching.map((e) => e.sessionId);
+    } else {
+      return 0;
+    }
+
+    if (targets.length === 0) return 0;
+
+    // Also drop them from each agent's in-memory list so getExecutions stays consistent.
+    const targetSet = new Set(targets);
+    for (const [agentId, list] of this.executions) {
+      const next = list.filter((e) => !targetSet.has(e.sessionId));
+      if (next.length !== list.length) this.executions.set(agentId, next);
+    }
+
+    return this.executionStore.deleteBySessionIds(targets);
+  }
+
   /** Handle session exit: mark the corresponding execution as completed. */
   handleSessionExited(sessionId: string, exitCode: number | null): void {
     for (const [, execs] of this.executions) {

package/server/agent-store.ts

@@ -2,12 +2,12 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
-  writeFileSync,
   unlinkSync,
   existsSync,
 } from "node:fs";
 import { join } from "node:path";
 import { HEYHANK_HOME } from "./paths.js";
+import { atomicWriteFileSync } from "./fs-utils.js";
 import { randomBytes } from "node:crypto";
 import type { AgentConfig, AgentConfigCreateInput } from "./agent-types.js";
 
@@ -115,7 +115,7 @@ export function createAgent(data: AgentConfigCreateInput): AgentConfig {
     totalRuns: 0,
     consecutiveFailures: 0,
   };
-  writeFileSync(filePath(id), JSON.stringify(agent, null, 2), "utf-8");
+  atomicWriteFileSync(filePath(id), JSON.stringify(agent, null, 2));
   return agent;
 }
 
@@ -155,7 +155,7 @@ export function updateAgent(
     }
   }
 
-  writeFileSync(filePath(newId), JSON.stringify(agent, null, 2), "utf-8");
+  atomicWriteFileSync(filePath(newId), JSON.stringify(agent, null, 2));
   return agent;
 }
 

package/server/agent-types.ts

@@ -49,6 +49,17 @@ export interface AgentConfig {
   // ── Skills ──
   /** Skill slugs to attach (from ~/.claude/skills/) */
   skills?: string[];
+  /**
+   * Skill-aware routing. When true (default), the agent is prepended with a
+   * generic skill-discovery preamble and the `Skill` tool is added to its
+   * allowedTools, so it can invoke any user-installed skill from
+   * ~/.claude/skills/ when a skill description matches the user's request.
+   *
+   * Only applies to Claude backends (Codex/Ollama/etc. don't support skills).
+   * Set to false for agents that must follow strict, scripted instructions
+   * without skill detours (e.g. low-level coordinator agents).
+   */
+  skillRouting?: boolean;
 
   // ── Docker ──
   /** Optional Docker container configuration */

package/server/assistant-store.ts

@@ -1,10 +1,18 @@
 // ─── Assistant Store ──────────────────────────────────────────────────────────
 // Persistent storage for personal assistant features: todos, notes, reminders.
 // All data stored as JSON in ~/.heyhank/assistant/
+// When an Obsidian vault is configured, delegates to vault-store.ts instead.
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from "node:fs";
+import { readFileSync, mkdirSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { HEYHANK_HOME } from "./paths.js";
+import { atomicWriteFileSync } from "./fs-utils.js";
+import { getSettings } from "./settings-manager.js";
+import * as vaultStore from "./vault-store.js";
+
+function useVault(): boolean {
+  return !!getSettings().obsidianVaultPath;
+}
 
 const ASSISTANT_DIR = join(HEYHANK_HOME, "assistant");
 
@@ -27,7 +35,7 @@ function readJson<T>(filename: string, fallback: T): T {
 
 function writeJson(filename: string, data: unknown): void {
   ensureDir();
-  writeFileSync(join(ASSISTANT_DIR, filename), JSON.stringify(data, null, 2), "utf-8");
+  atomicWriteFileSync(join(ASSISTANT_DIR, filename), JSON.stringify(data, null, 2));
 }
 
 // ─── Todos ────────────────────────────────────────────────────────────────────
@@ -40,6 +48,10 @@ export interface Todo {
   createdAt: string;
   doneAt?: string;
   category?: string;
+  delegatedTo?: string;
+  dueDate?: string;
+  followUpDate?: string;
+  project?: string;
 }
 
 function genId(): string {
@@ -47,6 +59,7 @@ function genId(): string {
 }
 
 export function listTodos(filter?: { done?: boolean; priority?: string; category?: string }): Todo[] {
+  if (useVault()) return vaultStore.listTodos(filter);
   const todos = readJson<Todo[]>("todos.json", []);
   return todos.filter((t) => {
     if (filter?.done !== undefined && t.done !== filter.done) return false;
@@ -56,7 +69,8 @@ export function listTodos(filter?: { done?: boolean; priority?: string; category
   });
 }
 
-export function addTodo(text: string, priority: string = "medium", category?: string): Todo {
+export function addTodo(text: string, priority: string = "medium", category?: string, extra?: { delegatedTo?: string; dueDate?: string; followUpDate?: string; project?: string }): Todo {
+  if (useVault()) return vaultStore.addTodo(text, priority, category, extra);
   const todos = readJson<Todo[]>("todos.json", []);
   const todo: Todo = {
     id: genId(),
@@ -65,6 +79,7 @@ export function addTodo(text: string, priority: string = "medium", category?: st
     done: false,
     createdAt: new Date().toISOString(),
     category,
+    ...extra,
   };
   todos.push(todo);
   writeJson("todos.json", todos);
@@ -72,6 +87,7 @@ export function addTodo(text: string, priority: string = "medium", category?: st
 }
 
 export function completeTodo(id: string): Todo | null {
+  if (useVault()) return vaultStore.completeTodo(id);
   const todos = readJson<Todo[]>("todos.json", []);
   const todo = todos.find((t) => t.id === id);
   if (!todo) return null;
@@ -82,6 +98,7 @@ export function completeTodo(id: string): Todo | null {
 }
 
 export function deleteTodo(id: string): boolean {
+  if (useVault()) return vaultStore.deleteTodo(id);
   const todos = readJson<Todo[]>("todos.json", []);
   const idx = todos.findIndex((t) => t.id === id);
   if (idx === -1) return false;
@@ -90,7 +107,8 @@ export function deleteTodo(id: string): boolean {
   return true;
 }
 
-export function updateTodo(id: string, patch: { text?: string; priority?: string; category?: string }): Todo | null {
+export function updateTodo(id: string, patch: { text?: string; priority?: string; category?: string; delegatedTo?: string; dueDate?: string; followUpDate?: string; project?: string }): Todo | null {
+  if (useVault()) return vaultStore.updateTodo(id, patch);
   const todos = readJson<Todo[]>("todos.json", []);
   const todo = todos.find((t) => t.id === id);
   if (!todo) return null;
@@ -99,10 +117,24 @@ export function updateTodo(id: string, patch: { text?: string; priority?: string
     todo.priority = patch.priority as Todo["priority"];
   }
   if (patch.category !== undefined) todo.category = patch.category;
+  if (patch.delegatedTo !== undefined) todo.delegatedTo = patch.delegatedTo;
+  if (patch.dueDate !== undefined) todo.dueDate = patch.dueDate;
+  if (patch.followUpDate !== undefined) todo.followUpDate = patch.followUpDate;
+  if (patch.project !== undefined) todo.project = patch.project;
   writeJson("todos.json", todos);
   return todo;
 }
 
+export function listDelegations(person?: string): Todo[] {
+  const todos = listTodos();
+  const delegated = todos.filter((t) => t.delegatedTo && (!person || t.delegatedTo.toLowerCase() === person.toLowerCase()));
+  return delegated.sort((a, b) => {
+    if (!a.dueDate) return 1;
+    if (!b.dueDate) return -1;
+    return a.dueDate.localeCompare(b.dueDate);
+  });
+}
+
 // ─── Notes ────────────────────────────────────────────────────────────────────
 
 export interface Note {
@@ -115,6 +147,7 @@ export interface Note {
 }
 
 export function listNotes(search?: string): Note[] {
+  if (useVault()) return vaultStore.listNotes(search);
   const notes = readJson<Note[]>("notes.json", []);
   if (!search) return notes;
   const q = search.toLowerCase();
@@ -126,6 +159,7 @@ export function listNotes(search?: string): Note[] {
 }
 
 export function addNote(title: string, content: string, tags: string[] = []): Note {
+  if (useVault()) return vaultStore.addNote(title, content, tags);
   const notes = readJson<Note[]>("notes.json", []);
   const note: Note = {
     id: genId(),
@@ -141,11 +175,13 @@ export function addNote(title: string, content: string, tags: string[] = []): No
 }
 
 export function getNote(id: string): Note | null {
+  if (useVault()) return vaultStore.getNote(id);
   const notes = readJson<Note[]>("notes.json", []);
   return notes.find((n) => n.id === id) || null;
 }
 
 export function updateNote(id: string, patch: { title?: string; content?: string; tags?: string[] }): Note | null {
+  if (useVault()) return vaultStore.updateNote(id, patch);
   const notes = readJson<Note[]>("notes.json", []);
   const note = notes.find((n) => n.id === id);
   if (!note) return null;
@@ -158,6 +194,7 @@ export function updateNote(id: string, patch: { title?: string; content?: string
 }
 
 export function deleteNote(id: string): boolean {
+  if (useVault()) return vaultStore.deleteNote(id);
   const notes = readJson<Note[]>("notes.json", []);
   const idx = notes.findIndex((n) => n.id === id);
   if (idx === -1) return false;
@@ -174,14 +211,17 @@ export interface Reminder {
   triggerAt: string; // ISO datetime
   fired: boolean;
   createdAt: string;
+  calendarEventUid?: string;
 }
 
 export function listReminders(includeFired = false): Reminder[] {
+  if (useVault()) return vaultStore.listReminders(includeFired);
   const reminders = readJson<Reminder[]>("reminders.json", []);
   return includeFired ? reminders : reminders.filter((r) => !r.fired);
 }
 
-export function addReminder(text: string, triggerAt: string): Reminder {
+export function addReminder(text: string, triggerAt: string, calendarEventUid?: string): Reminder {
+  if (useVault()) return vaultStore.addReminder(text, triggerAt, calendarEventUid);
   const reminders = readJson<Reminder[]>("reminders.json", []);
   const reminder: Reminder = {
     id: genId(),
@@ -189,13 +229,27 @@ export function addReminder(text: string, triggerAt: string): Reminder {
     triggerAt,
     fired: false,
     createdAt: new Date().toISOString(),
+    ...(calendarEventUid ? { calendarEventUid } : {}),
   };
   reminders.push(reminder);
   writeJson("reminders.json", reminders);
   return reminder;
 }
 
+export function updateReminder(id: string, updates: { text?: string; triggerAt?: string; calendarEventUid?: string }): Reminder | null {
+  if (useVault()) return vaultStore.updateReminder(id, updates);
+  const reminders = readJson<Reminder[]>("reminders.json", []);
+  const r = reminders.find((rem) => rem.id === id);
+  if (!r) return null;
+  if (updates.text !== undefined) r.text = updates.text;
+  if (updates.triggerAt !== undefined) r.triggerAt = updates.triggerAt;
+  if (updates.calendarEventUid !== undefined) r.calendarEventUid = updates.calendarEventUid;
+  writeJson("reminders.json", reminders);
+  return r;
+}
+
 export function fireReminder(id: string): Reminder | null {
+  if (useVault()) return vaultStore.fireReminder(id);
   const reminders = readJson<Reminder[]>("reminders.json", []);
   const r = reminders.find((rem) => rem.id === id);
   if (!r) return null;
@@ -205,6 +259,7 @@ export function fireReminder(id: string): Reminder | null {
 }
 
 export function deleteReminder(id: string): boolean {
+  if (useVault()) return vaultStore.deleteReminder(id);
   const reminders = readJson<Reminder[]>("reminders.json", []);
   const idx = reminders.findIndex((r) => r.id === id);
   if (idx === -1) return false;
@@ -215,12 +270,179 @@ export function deleteReminder(id: string): boolean {
 
 /** Get all reminders that should have fired by now */
 export function getDueReminders(): Reminder[] {
+  if (useVault()) return vaultStore.getDueReminders();
   const now = new Date().toISOString();
   const reminders = readJson<Reminder[]>("reminders.json", []);
   return reminders.filter((r) => !r.fired && r.triggerAt <= now);
 }
 
-// ─── Gemini Conversations ──────��─────────────────────────────────────────────
+// ─── Contacts/CRM ────────────────────────────────────────────────────────────
+
+export interface ContactInteraction {
+  date: string;
+  type: "call" | "email" | "meeting" | "note";
+  summary: string;
+}
+
+export interface Contact {
+  id: string;
+  name: string;
+  company?: string;
+  email?: string;
+  phone?: string;
+  notes?: string;
+  tags: string[];
+  lastContactDate?: string;
+  interactions: ContactInteraction[];
+  createdAt: string;
+  updatedAt: string;
+}
+
+export function listContacts(search?: string): Contact[] {
+  if (useVault()) return vaultStore.listContacts(search);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  if (!search) return contacts;
+  const q = search.toLowerCase();
+  return contacts.filter((c) =>
+    c.name.toLowerCase().includes(q) ||
+    (c.company && c.company.toLowerCase().includes(q)) ||
+    (c.email && c.email.toLowerCase().includes(q)) ||
+    (c.phone && c.phone.includes(q)) ||
+    c.tags.some((t) => t.toLowerCase().includes(q))
+  );
+}
+
+export function addContact(name: string, company?: string, email?: string, phone?: string, notes?: string, tags: string[] = []): Contact {
+  if (useVault()) return vaultStore.addContact(name, company, email, phone, notes, tags);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  const contact: Contact = {
+    id: genId(),
+    name,
+    company,
+    email,
+    phone,
+    notes,
+    tags,
+    interactions: [],
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+  };
+  contacts.push(contact);
+  writeJson("contacts.json", contacts);
+  return contact;
+}
+
+export function getContact(id: string): Contact | null {
+  if (useVault()) return vaultStore.getContact(id);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  return contacts.find((c) => c.id === id) || null;
+}
+
+export function updateContact(id: string, patch: { name?: string; company?: string; email?: string; phone?: string; notes?: string; tags?: string[] }): Contact | null {
+  if (useVault()) return vaultStore.updateContact(id, patch);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  const contact = contacts.find((c) => c.id === id);
+  if (!contact) return null;
+  if (patch.name) contact.name = patch.name;
+  if (patch.company !== undefined) contact.company = patch.company;
+  if (patch.email !== undefined) contact.email = patch.email;
+  if (patch.phone !== undefined) contact.phone = patch.phone;
+  if (patch.notes !== undefined) contact.notes = patch.notes;
+  if (patch.tags) contact.tags = patch.tags;
+  contact.updatedAt = new Date().toISOString();
+  writeJson("contacts.json", contacts);
+  return contact;
+}
+
+export function deleteContact(id: string): boolean {
+  if (useVault()) return vaultStore.deleteContact(id);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  const idx = contacts.findIndex((c) => c.id === id);
+  if (idx === -1) return false;
+  contacts.splice(idx, 1);
+  writeJson("contacts.json", contacts);
+  return true;
+}
+
+export function logInteraction(contactId: string, interaction: Omit<ContactInteraction, "date">): Contact | null {
+  if (useVault()) return vaultStore.logInteraction(contactId, interaction);
+  const contacts = readJson<Contact[]>("contacts.json", []);
+  const contact = contacts.find((c) => c.id === contactId);
+  if (!contact) return null;
+  const entry: ContactInteraction = {
+    date: new Date().toISOString(),
+    type: interaction.type,
+    summary: interaction.summary,
+  };
+  contact.interactions.push(entry);
+  contact.lastContactDate = entry.date;
+  contact.updatedAt = new Date().toISOString();
+  writeJson("contacts.json", contacts);
+  return contact;
+}
+
+// ─── Decisions ───────────────────────────────────────────────────────────────
+
+export interface Decision {
+  id: string;
+  title: string;
+  context: string;
+  decision: string;
+  alternatives: string[];
+  reasoning: string;
+  tags: string[];
+  createdAt: string;
+}
+
+export function listDecisions(search?: string): Decision[] {
+  if (useVault()) return vaultStore.listDecisions(search);
+  const decisions = readJson<Decision[]>("decisions.json", []);
+  if (!search) return decisions;
+  const q = search.toLowerCase();
+  return decisions.filter((d) =>
+    d.title.toLowerCase().includes(q) ||
+    d.context.toLowerCase().includes(q) ||
+    d.decision.toLowerCase().includes(q) ||
+    d.reasoning.toLowerCase().includes(q) ||
+    d.tags.some((t) => t.toLowerCase().includes(q))
+  );
+}
+
+export function addDecision(title: string, context: string, decision: string, alternatives: string[] = [], reasoning: string = "", tags: string[] = []): Decision {
+  if (useVault()) return vaultStore.addDecision(title, context, decision, alternatives, reasoning, tags);
+  const decisions = readJson<Decision[]>("decisions.json", []);
+  const entry: Decision = {
+    id: genId(),
+    title,
+    context,
+    decision,
+    alternatives,
+    reasoning,
+    tags,
+    createdAt: new Date().toISOString(),
+  };
+  decisions.push(entry);
+  writeJson("decisions.json", decisions);
+  return entry;
+}
+
+export function getDecision(id: string): Decision | null {
+  if (useVault()) return vaultStore.getDecision(id);
+  const decisions = readJson<Decision[]>("decisions.json", []);
+  return decisions.find((d) => d.id === id) || null;
+}
+
+export function deleteDecision(id: string): boolean {
+  if (useVault()) return vaultStore.deleteDecision(id);
+  const decisions = readJson<Decision[]>("decisions.json", []);
+  const idx = decisions.findIndex((d) => d.id === id);
+  if (idx === -1) return false;
+  decisions.splice(idx, 1);
+  writeJson("decisions.json", decisions);
+  return true;
+}
+
+// ─── Gemini Conversations ────────────────────────────────────────────────────
 
 export interface GeminiConversation {
   id: string;
@@ -231,6 +453,7 @@ export interface GeminiConversation {
 }
 
 export function listGeminiConversations(): GeminiConversation[] {
+  if (useVault()) return vaultStore.listGeminiConversations();
   return readJson<GeminiConversation[]>("gemini-conversations.json", [])
     .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
 }
@@ -239,6 +462,7 @@ export function saveGeminiConversation(
   messages: Array<{ role: "user" | "gemini" | "system"; text: string; ts: number }>,
   duration?: number,
 ): GeminiConversation {
+  if (useVault()) return vaultStore.saveGeminiConversation(messages, duration);
   const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
   // Generate title from first user message
   const firstUser = messages.find((m) => m.role === "user");
@@ -258,11 +482,13 @@ export function saveGeminiConversation(
 }
 
 export function getGeminiConversation(id: string): GeminiConversation | null {
+  if (useVault()) return vaultStore.getGeminiConversation(id);
   const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
   return convos.find((c) => c.id === id) || null;
 }
 
 export function deleteGeminiConversation(id: string): boolean {
+  if (useVault()) return vaultStore.deleteGeminiConversation(id);
   const convos = readJson<GeminiConversation[]>("gemini-conversations.json", []);
   const idx = convos.findIndex((c) => c.id === id);
   if (idx === -1) return false;

package/server/auth-manager.ts

@@ -144,6 +144,15 @@ export function regenerateToken(): string {
   return token;
 }
 
+/**
+ * Check whether a token file already exists on disk (i.e. not a fresh first-run).
+ * Used to decide whether to print the token to console on startup.
+ */
+export function isTokenPersisted(): boolean {
+  if (process.env.HEYHANK_AUTH_TOKEN || process.env.COMPANION_AUTH_TOKEN) return true;
+  return existsSync(AUTH_FILE);
+}
+
 /** Reset cached state — for testing only */
 export function _resetForTest(): void {
   cachedToken = null;

package/server/cache-headers.ts

@@ -31,7 +31,7 @@ export function cacheControlMiddleware(): MiddlewareHandler {
 
     // index.html (served for / and /index.html): must be fresh
     if (path === "/" || path === "/index.html") {
-      c.header("Cache-Control", "no-cache");
+      c.header("Cache-Control", "no-store, no-cache, must-revalidate, max-age=0");
       return;
     }
 

package/server/calendar-service.ts

@@ -291,6 +291,7 @@ export async function createEvent(
     end: string;         // ISO datetime or YYYY-MM-DD for all-day
     allDay?: boolean;
     calendarUrl?: string;
+    alarm?: number;      // minutes before event to trigger alarm (0 = at event time)
   },
 ): Promise<{ success: boolean; uid: string }> {
   const client = await createClient(account);
@@ -330,6 +331,15 @@ export async function createEvent(
   if (event.description) lines.push(`DESCRIPTION:${escapeICS(event.description)}`);
   if (event.location) lines.push(`LOCATION:${escapeICS(event.location)}`);
   lines.push(`DTSTAMP:${new Date().toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "")}`);
+  if (event.alarm !== undefined) {
+    lines.push(
+      "BEGIN:VALARM",
+      "ACTION:DISPLAY",
+      `DESCRIPTION:${escapeICS(event.summary)}`,
+      `TRIGGER:${event.alarm === 0 ? "PT0S" : `-PT${event.alarm}M`}`,
+      "END:VALARM",
+    );
+  }
   lines.push("END:VEVENT", "END:VCALENDAR");
 
   const icsData = lines.join("\r\n");