claude-threads 1.28.0 → 1.29.0

package/dist/mcp/mcp-server.js

@@ -51265,7 +51265,8 @@ class PromptExecutor extends BaseExecutor {
       pendingContextPrompt: null,
       pendingExistingWorktreePrompt: null,
       pendingUpdatePrompt: null,
-      pendingRoutinePrompt: null
+      pendingRoutinePrompt: null,
+      pendingWatchPrompt: null
     };
   }
   getInitialState() {
@@ -51276,7 +51277,8 @@ class PromptExecutor extends BaseExecutor {
       pendingContextPrompt: this.state.pendingContextPrompt ? { ...this.state.pendingContextPrompt } : null,
       pendingExistingWorktreePrompt: this.state.pendingExistingWorktreePrompt ? { ...this.state.pendingExistingWorktreePrompt } : null,
       pendingUpdatePrompt: this.state.pendingUpdatePrompt ? { ...this.state.pendingUpdatePrompt } : null,
-      pendingRoutinePrompt: this.state.pendingRoutinePrompt ? { ...this.state.pendingRoutinePrompt } : null
+      pendingRoutinePrompt: this.state.pendingRoutinePrompt ? { ...this.state.pendingRoutinePrompt } : null,
+      pendingWatchPrompt: this.state.pendingWatchPrompt ? { ...this.state.pendingWatchPrompt } : null
     };
   }
   hydrateState(persisted) {
@@ -51284,7 +51286,8 @@ class PromptExecutor extends BaseExecutor {
       pendingContextPrompt: persisted.pendingContextPrompt ?? null,
       pendingExistingWorktreePrompt: persisted.pendingExistingWorktreePrompt ?? null,
       pendingUpdatePrompt: persisted.pendingUpdatePrompt ?? null,
-      pendingRoutinePrompt: null
+      pendingRoutinePrompt: null,
+      pendingWatchPrompt: null
     };
   }
   setPendingContextPrompt(prompt) {
@@ -51420,24 +51423,36 @@ class PromptExecutor extends BaseExecutor {
   hasPendingRoutinePrompt() {
     return this.state.pendingRoutinePrompt !== null;
   }
-  async handleRoutinePromptResponse(postId, approved, username, ctx) {
-    if (!this.state.pendingRoutinePrompt)
+  async completeCreationPrompt(pending, label, clear, emit, postId, approved, username, ctx) {
+    if (!pending || pending.postId !== postId)
       return false;
-    if (this.state.pendingRoutinePrompt.postId !== postId)
-      return false;
-    const { parsed, requestedBy } = this.state.pendingRoutinePrompt;
-    const statusMessage = approved ? `✅ ${ctx.formatter.formatBold(`Routine "${parsed.name}" confirmed`)} by ${ctx.formatter.formatUserMention(username)} — saving...` : `❌ ${ctx.formatter.formatBold(`Routine "${parsed.name}" discarded`)} by ${ctx.formatter.formatUserMention(username)}`;
+    const { parsed, requestedBy } = pending;
+    const statusMessage = approved ? `✅ ${ctx.formatter.formatBold(`${label} "${parsed.name}" confirmed`)} by ${ctx.formatter.formatUserMention(username)} — saving...` : `❌ ${ctx.formatter.formatBold(`${label} "${parsed.name}" discarded`)} by ${ctx.formatter.formatUserMention(username)}`;
     try {
       await ctx.platform.updatePost(postId, statusMessage);
     } catch (err) {
-      ctx.logger.debug(`Failed to update routine prompt post: ${err}`);
-    }
-    this.state.pendingRoutinePrompt = null;
-    if (this.events) {
-      this.events.emit("routine-prompt:complete", { approved, parsed, requestedBy, postId });
+      ctx.logger.debug(`Failed to update ${label.toLowerCase()} prompt post: ${err}`);
     }
+    clear();
+    emit({ approved, parsed, requestedBy, postId });
     return true;
   }
+  handleRoutinePromptResponse(postId, approved, username, ctx) {
+    return this.completeCreationPrompt(this.state.pendingRoutinePrompt, "Routine", () => {
+      this.state.pendingRoutinePrompt = null;
+    }, (payload) => this.events?.emit("routine-prompt:complete", payload), postId, approved, username, ctx);
+  }
+  setPendingWatchPrompt(prompt) {
+    this.state.pendingWatchPrompt = prompt;
+  }
+  hasPendingWatchPrompt() {
+    return this.state.pendingWatchPrompt !== null;
+  }
+  handleWatchPromptResponse(postId, approved, username, ctx) {
+    return this.completeCreationPrompt(this.state.pendingWatchPrompt, "Watch", () => {
+      this.state.pendingWatchPrompt = null;
+    }, (payload) => this.events?.emit("watch-prompt:complete", payload), postId, approved, username, ctx);
+  }
   async handleReaction(postId, emoji4, user, action, ctx) {
     ctx.logger.debug(`PromptExecutor.handleReaction: postId=${postId.substring(0, 8)}, emoji=${emoji4}, user=${user}, action=${action}`);
     if (action !== "added") {
@@ -51510,6 +51525,18 @@ class PromptExecutor extends BaseExecutor {
       ctx.logger.debug(`PromptExecutor: emoji ${emoji4} not valid for routine prompt, ignoring`);
       return false;
     }
+    if (this.state.pendingWatchPrompt?.postId === postId) {
+      if (isApprovalEmoji(emoji4)) {
+        ctx.logger.debug(`Watch prompt reaction from @${user}: approve`);
+        return this.handleWatchPromptResponse(postId, true, user, ctx);
+      }
+      if (isDenialEmoji(emoji4)) {
+        ctx.logger.debug(`Watch prompt reaction from @${user}: discard`);
+        return this.handleWatchPromptResponse(postId, false, user, ctx);
+      }
+      ctx.logger.debug(`PromptExecutor: emoji ${emoji4} not valid for watch prompt, ignoring`);
+      return false;
+    }
     ctx.logger.debug(`PromptExecutor: no pending prompt state matches postId=${postId.substring(0, 8)}`);
     return false;
   }
@@ -52057,6 +52084,9 @@ class MessageManager {
   setPendingRoutinePrompt(prompt) {
     this.promptExecutor.setPendingRoutinePrompt(prompt);
   }
+  setPendingWatchPrompt(prompt) {
+    this.promptExecutor.setPendingWatchPrompt(prompt);
+  }
   setPendingBugReport(report) {
     this.bugReportExecutor.setPendingBugReport(report);
   }
@@ -56957,6 +56987,27 @@ var COMMAND_REGISTRY = [
       { name: "run", description: "Run a routine now, outside its schedule", args: "<n>" }
     ]
   },
+  {
+    command: "watch",
+    description: "Create an event trigger from a natural-language request (confirmed with \uD83D\uDC4D before saving)",
+    args: "<when ..., task>",
+    category: "settings",
+    audience: "user",
+    claudeNotes: "User decisions, not yours"
+  },
+  {
+    command: "watches",
+    description: "List event triggers; pause/resume/delete manage them",
+    args: "[pause|resume|delete <n>]",
+    category: "settings",
+    audience: "user",
+    claudeNotes: "User decisions, not yours",
+    subcommands: [
+      { name: "pause", description: "Pause a watch", args: "<n>" },
+      { name: "resume", description: "Resume a paused watch", args: "<n>" },
+      { name: "delete", description: "Delete a watch", args: "<n>" }
+    ]
+  },
   {
     command: "update",
     description: "Show auto-update status",
@@ -57255,6 +57306,30 @@ var handleRoutines = async (ctx, args) => {
   await ctx.sessionManager.manageRoutines(ctx.threadId, args, ctx.username);
   return { handled: true };
 };
+var handleWatch = async (ctx, args) => {
+  if (ctx.commandContext === "first-message") {
+    return { handled: false };
+  }
+  if (!ctx.isAllowed) {
+    return { handled: true };
+  }
+  if (!args?.trim()) {
+    await ctx.client.createPost(`⚠️ Usage: ${ctx.formatter.formatCode("!watch when <something happens>, <task>")}`, ctx.threadId);
+    return { handled: true };
+  }
+  await ctx.sessionManager.createWatch(ctx.threadId, args, ctx.username);
+  return { handled: true };
+};
+var handleWatches = async (ctx, args) => {
+  if (ctx.commandContext === "first-message") {
+    return { handled: false };
+  }
+  if (!ctx.isAllowed) {
+    return { handled: true };
+  }
+  await ctx.sessionManager.manageWatches(ctx.threadId, args, ctx.username);
+  return { handled: true };
+};
 var handleCd = async (ctx, args) => {
   if (!args) {
     return { handled: false };
@@ -57448,6 +57523,8 @@ handlers.set("remember", handleRemember);
 handlers.set("memory", handleMemory);
 handlers.set("routine", handleRoutine);
 handlers.set("routines", handleRoutines);
+handlers.set("watch", handleWatch);
+handlers.set("watches", handleWatches);
 handlers.set("cd", handleCd);
 handlers.set("permissions", handlePermissions);
 handlers.set("mentions", handleMentions);
@@ -57589,16 +57666,35 @@ var contextPromptFiles = new Map;
 // src/memory/store.ts
 import { createHash } from "crypto";
 import {
-  chmodSync as chmodSync2,
   existsSync as existsSync5,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync4,
-  renameSync,
-  realpathSync,
-  writeFileSync as writeFileSync2
+  realpathSync
 } from "fs";
 import { homedir as homedir5 } from "os";
 import { basename as basename3, dirname as dirname7, join as join7, sep as sep2 } from "path";
+
+// src/persistence/atomic-file.ts
+import { chmodSync as chmodSync2, renameSync, writeFileSync as writeFileSync2 } from "fs";
+
+class SerialQueue {
+  tail = Promise.resolve();
+  run(fn) {
+    const next = this.tail.then(fn, fn);
+    this.tail = next.catch(() => {
+      return;
+    });
+    return next;
+  }
+}
+function writeFileAtomic(file2, content) {
+  const tempFile = `${file2}.tmp`;
+  writeFileSync2(tempFile, content, { encoding: "utf-8", mode: 384 });
+  renameSync(tempFile, file2);
+  chmodSync2(file2, 384);
+}
+
+// src/memory/store.ts
 var log18 = createLogger("memory");
 var DEFAULT_ROOT = join7(homedir5(), ".config", "claude-threads", "memory");
 var CHANNEL_BLOCK_MAX_LINES = 200;
@@ -57771,12 +57867,12 @@ class MemoryStore {
 _(older entries omitted — \`!memory\` shows all)_` : rendered;
   }
   runExclusive(platformId, fn) {
-    const tail = this.locks.get(platformId) ?? Promise.resolve();
-    const next = tail.then(fn, fn);
-    this.locks.set(platformId, next.catch(() => {
-      return;
-    }));
-    return next;
+    let queue = this.locks.get(platformId);
+    if (!queue) {
+      queue = new SerialQueue;
+      this.locks.set(platformId, queue);
+    }
+    return queue.run(fn);
   }
   loadLines(platformId) {
     const file2 = this.channelMemoryPath(platformId);
@@ -57819,10 +57915,7 @@ _(older entries omitted — \`!memory\` shows all)_` : rendered;
     const content = [FILE_HEADER, ...lines.map((l) => l.raw)].join(`
 `) + `
 `;
-    const tempFile = `${file2}.tmp`;
-    writeFileSync2(tempFile, content, { encoding: "utf-8", mode: 384 });
-    renameSync(tempFile, file2);
-    chmodSync2(file2, 384);
+    writeFileAtomic(file2, content);
   }
   ensureDir(dir) {
     if (!existsSync5(dir)) {
@@ -57834,6 +57927,117 @@ _(older entries omitted — \`!memory\` shows all)_` : rendered;
 // src/memory/distiller.ts
 var log19 = createLogger("memory");
 
+// src/session/registry.ts
+function compositeSessionId(platformId, threadId) {
+  return `${platformId}:${threadId}`;
+}
+
+class SessionRegistry {
+  sessions = new Map;
+  postIndex = new Map;
+  sessionStore;
+  constructor(sessionStore) {
+    this.sessionStore = sessionStore;
+  }
+  getSessionId(platformId, threadId) {
+    return compositeSessionId(platformId, threadId);
+  }
+  parseSessionId(sessionId) {
+    const colonIndex = sessionId.indexOf(":");
+    if (colonIndex === -1)
+      return null;
+    return {
+      platformId: sessionId.substring(0, colonIndex),
+      threadId: sessionId.substring(colonIndex + 1)
+    };
+  }
+  find(platformId, threadId) {
+    return this.sessions.get(this.getSessionId(platformId, threadId));
+  }
+  findByThreadId(threadId) {
+    for (const session of this.sessions.values()) {
+      if (session.threadId === threadId) {
+        return session;
+      }
+    }
+    return;
+  }
+  findByPost(postId) {
+    const threadId = this.postIndex.get(postId);
+    if (!threadId)
+      return;
+    return this.findByThreadId(threadId);
+  }
+  get(sessionId) {
+    return this.sessions.get(sessionId);
+  }
+  has(platformId, threadId) {
+    return this.sessions.has(this.getSessionId(platformId, threadId));
+  }
+  isActiveThread(threadId) {
+    return this.findByThreadId(threadId) !== undefined;
+  }
+  register(session) {
+    this.sessions.set(session.sessionId, session);
+  }
+  unregister(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  registerPost(postId, threadId) {
+    this.postIndex.set(postId, threadId);
+  }
+  unregisterPost(postId) {
+    this.postIndex.delete(postId);
+  }
+  clearPostsForThread(threadId) {
+    for (const [postId, tid] of this.postIndex.entries()) {
+      if (tid === threadId) {
+        this.postIndex.delete(postId);
+      }
+    }
+  }
+  getAll() {
+    return Array.from(this.sessions.values());
+  }
+  getActiveThreadIds() {
+    return Array.from(this.sessions.values()).map((s) => s.threadId);
+  }
+  get size() {
+    return this.sessions.size;
+  }
+  getForPlatform(platformId) {
+    return Array.from(this.sessions.values()).filter((s) => s.sessionId.startsWith(`${platformId}:`));
+  }
+  hasPaused(platformId, threadId) {
+    return this.sessionStore.findByThread(platformId, threadId) !== undefined;
+  }
+  getPersisted(platformId, threadId) {
+    return this.sessionStore.findByThread(platformId, threadId);
+  }
+  getPersistedByThreadId(threadId) {
+    return this.sessionStore.findByThreadIdAnyState(threadId);
+  }
+  getSessionStore() {
+    return this.sessionStore;
+  }
+  hasById(sessionId) {
+    return this.sessions.has(sessionId);
+  }
+  clear() {
+    this.sessions.clear();
+    this.postIndex.clear();
+  }
+  getThreadIdForPost(postId) {
+    return this.postIndex.get(postId);
+  }
+  getSessions() {
+    return this.sessions;
+  }
+  getPostIndex() {
+    return this.postIndex;
+  }
+}
+
 // src/session/lifecycle.ts
 var log20 = createLogger("lifecycle");
 var sessionLog3 = createSessionLog(log20);
@@ -57853,199 +58057,174 @@ var DEFAULT_CONFIG_DIR = join8(homedir6(), ".config", "claude-threads");
 var DEFAULT_FILE = join8(DEFAULT_CONFIG_DIR, "github-emails.yaml");
 
 // src/persistence/routines-store.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5 } from "fs";
+import { join as join10 } from "path";
+
+// src/persistence/platform-list-store.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync5, statSync as statSync2 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join9 } from "path";
-import { randomUUID as randomUUID2 } from "crypto";
-
-// src/persistence/atomic-file.ts
-import { chmodSync as chmodSync3, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
-
-class SerialQueue {
-  tail = Promise.resolve();
-  run(fn) {
-    const next = this.tail.then(fn, fn);
-    this.tail = next.catch(() => {
-      return;
-    });
-    return next;
-  }
-}
-function writeFileAtomic(file2, content) {
-  const tempFile = `${file2}.tmp`;
-  writeFileSync3(tempFile, content, { encoding: "utf-8", mode: 384 });
-  renameSync2(tempFile, file2);
-  chmodSync3(file2, 384);
-}
-
-// src/persistence/routines-store.ts
-var log22 = createLogger("routines");
-var DEFAULT_CONFIG_DIR2 = join9(homedir7(), ".config", "claude-threads");
-var DEFAULT_FILE2 = join9(DEFAULT_CONFIG_DIR2, "routines.yaml");
+var STORES_CONFIG_DIR = join9(homedir7(), ".config", "claude-threads");
 var STORE_VERSION = 1;
-var DEFAULT_MAX_ROUTINES = 10;
-var SCHEDULE_PRESETS = ["hourly", "daily", "weekdays", "weekly"];
-var TIME_RE = /^([01]\d|2[0-3]):[0-5]\d$/;
-function isValidTimezone(tz) {
-  if (typeof tz !== "string" || !tz)
-    return false;
-  try {
-    new Intl.DateTimeFormat("en-US", { timeZone: tz });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function validateSchedule(schedule) {
-  if (!SCHEDULE_PRESETS.includes(schedule.preset)) {
-    return `unknown preset "${String(schedule.preset)}" (expected ${SCHEDULE_PRESETS.join("/")})`;
-  }
-  if (!isValidTimezone(schedule.timezone)) {
-    return `invalid timezone "${String(schedule.timezone)}"`;
-  }
-  if (schedule.preset === "hourly") {
-    return null;
-  }
-  if (!schedule.time || !TIME_RE.test(schedule.time)) {
-    return `invalid time "${String(schedule.time)}" (expected HH:MM, 24h)`;
-  }
-  if (schedule.preset === "weekly") {
-    const weekday = schedule.weekday;
-    if (typeof weekday !== "number" || !Number.isInteger(weekday) || weekday < 1 || weekday > 7) {
-      return `invalid weekday "${String(weekday)}" (expected 1=Mon … 7=Sun)`;
-    }
-  }
-  return null;
-}
-class RoutinesStore {
+
+class PlatformListStore {
   file;
   configDir;
   queue = new SerialQueue;
-  constructor(filePath) {
-    const effective = filePath ?? process.env.CLAUDE_THREADS_ROUTINES_PATH;
-    if (effective) {
-      this.file = effective;
-      this.configDir = join9(effective, "..");
+  collectionKey;
+  cache = null;
+  constructor(collectionKey, defaultFile, filePath) {
+    this.collectionKey = collectionKey;
+    if (filePath) {
+      this.file = filePath;
+      this.configDir = join9(filePath, "..");
     } else {
-      this.file = DEFAULT_FILE2;
-      this.configDir = DEFAULT_CONFIG_DIR2;
-    }
-    if (!existsSync6(this.configDir)) {
-      mkdirSync3(this.configDir, { recursive: true, mode: 448 });
+      this.file = defaultFile;
+      this.configDir = STORES_CONFIG_DIR;
     }
+    mkdirSync3(this.configDir, { recursive: true, mode: 448 });
   }
   list(platformId) {
-    return this.loadRaw().routines[platformId] ?? [];
+    return structuredClone(this.loadRaw().items[platformId] ?? []);
   }
   get(platformId, id) {
-    return this.list(platformId).find((r) => r.id === id);
+    const item = (this.loadRaw().items[platformId] ?? []).find((i) => i.id === id);
+    return item === undefined ? undefined : structuredClone(item);
   }
-  add(platformId, routine, maxRoutines = DEFAULT_MAX_ROUTINES) {
+  addItem(platformId, max, capNoun, build) {
     return this.runExclusive(() => {
-      const scheduleError = validateSchedule(routine.schedule);
-      if (scheduleError)
-        return { ok: false, error: scheduleError };
-      const name = routine.name.trim().slice(0, 80);
-      const prompt = routine.prompt.trim().slice(0, 2000);
-      if (!name || !prompt)
-        return { ok: false, error: "name and prompt are required" };
-      const data = this.loadRaw();
-      const existing = data.routines[platformId] ?? [];
-      if (existing.length >= maxRoutines) {
-        return { ok: false, error: `routine limit reached (${maxRoutines}); delete one first` };
-      }
-      const full = {
-        ...routine,
-        name,
-        prompt,
-        id: randomUUID2().slice(0, 8),
-        createdAt: new Date().toISOString(),
-        enabled: true,
-        consecutiveFailures: 0
-      };
-      data.routines[platformId] = [...existing, full];
+      const built = build();
+      if (typeof built === "string")
+        return { ok: false, error: built };
+      const data = this.loadRaw(true);
+      const existing = data.items[platformId] ?? [];
+      if (existing.length >= max) {
+        return { ok: false, error: `${capNoun} limit reached (${max}); delete one first` };
+      }
+      data.items[platformId] = [...existing, built];
       this.writeAtomic(data);
-      log22.info(`Routine "${full.name}" created on ${platformId} by @${full.createdBy}`);
-      return { ok: true, routine: full };
+      return { ok: true, item: structuredClone(built) };
     });
   }
   update(platformId, id, patch) {
     return this.runExclusive(() => {
-      const data = this.loadRaw();
-      const routines = data.routines[platformId] ?? [];
-      const idx = routines.findIndex((r) => r.id === id);
+      const data = this.loadRaw(true);
+      const items = data.items[platformId] ?? [];
+      const idx = items.findIndex((item) => item.id === id);
       if (idx < 0)
         return;
-      routines[idx] = { ...routines[idx], ...patch };
+      items[idx] = { ...items[idx], ...patch };
       this.writeAtomic(data);
-      return routines[idx];
+      return structuredClone(items[idx]);
     });
   }
   remove(platformId, id) {
     return this.runExclusive(() => {
-      const data = this.loadRaw();
-      const routines = data.routines[platformId] ?? [];
-      const idx = routines.findIndex((r) => r.id === id);
+      const data = this.loadRaw(true);
+      const items = data.items[platformId] ?? [];
+      const idx = items.findIndex((item) => item.id === id);
       if (idx < 0)
         return;
-      const [removed] = routines.splice(idx, 1);
-      if (routines.length === 0)
-        delete data.routines[platformId];
+      const [removed] = items.splice(idx, 1);
+      if (items.length === 0)
+        delete data.items[platformId];
       this.writeAtomic(data);
-      log22.info(`Routine "${removed.name}" removed from ${platformId}`);
+      this.onRemoved(platformId, removed);
       return removed;
     });
   }
+  onRemoved(_platformId, _item) {}
   runExclusive(fn) {
     return this.queue.run(fn);
   }
-  loadRaw() {
+  loadRaw(forWrite = false) {
     if (!existsSync6(this.file)) {
-      return { version: STORE_VERSION, routines: {} };
+      this.cache = null;
+      return { version: STORE_VERSION, items: {} };
     }
     try {
-      const parsed = yaml.load(readFileSync5(this.file, "utf-8"));
-      if (!parsed || typeof parsed !== "object") {
-        return { version: STORE_VERSION, routines: {} };
+      const stat = statSync2(this.file);
+      if (this.cache && this.cache.mtimeMs === stat.mtimeMs && this.cache.size === stat.size) {
+        return this.cache.data;
       }
-      const routines = parsed.routines && typeof parsed.routines === "object" ? parsed.routines : {};
-      for (const list of Object.values(routines)) {
-        for (const r of list) {
-          r.enabled = r.enabled ?? true;
-          r.consecutiveFailures = r.consecutiveFailures ?? 0;
-        }
-      }
-      return { version: parsed.version ?? STORE_VERSION, routines };
+      const parsed = yaml.load(readFileSync5(this.file, "utf-8"));
+      const rawItems = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed[this.collectionKey] : undefined;
+      if (rawItems !== null && (rawItems === undefined || typeof rawItems !== "object" || Array.isArray(rawItems))) {
+        this.cache = null;
+        const problem = `unexpected shape (missing or non-map '${this.collectionKey}' key)`;
+        if (forWrite) {
+          throw new Error(`refusing to write over unreadable ${this.file}: ${problem}`);
+        }
+        this.warn(`Failed to read ${this.file}: ${problem} — starting empty`);
+        return { version: STORE_VERSION, items: {} };
+      }
+      const items = rawItems ?? {};
+      for (const list of Object.values(items)) {
+        for (const item of list)
+          this.applyItemDefaults(item);
+      }
+      const data = { version: parsed?.version ?? STORE_VERSION, items };
+      this.cache = { mtimeMs: stat.mtimeMs, size: stat.size, data };
+      return data;
     } catch (err) {
-      log22.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
-      return { version: STORE_VERSION, routines: {} };
+      this.cache = null;
+      if (forWrite) {
+        throw new Error(`refusing to write over unreadable ${this.file}: ${err.message}`, { cause: err });
+      }
+      this.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
+      return { version: STORE_VERSION, items: {} };
     }
   }
   writeAtomic(data) {
-    writeFileAtomic(this.file, yaml.dump(data, { sortKeys: true, lineWidth: -1 }));
+    try {
+      this.persistFile(yaml.dump({ version: data.version, [this.collectionKey]: data.items }, { sortKeys: true, lineWidth: -1 }));
+    } catch (err) {
+      this.cache = null;
+      throw err;
+    }
+    try {
+      const stat = statSync2(this.file);
+      this.cache = { mtimeMs: stat.mtimeMs, size: stat.size, data };
+    } catch {
+      this.cache = null;
+    }
+  }
+  persistFile(content) {
+    writeFileAtomic(this.file, content);
   }
 }
 
+// src/persistence/routines-store.ts
+var log22 = createLogger("routines");
+var DEFAULT_FILE2 = join10(STORES_CONFIG_DIR, "routines.yaml");
+
 // src/routines/parser.ts
 var log23 = createLogger("routines");
 
+// src/persistence/watches-store.ts
+import { join as join11 } from "path";
+var log24 = createLogger("watches");
+var DEFAULT_FILE3 = join11(STORES_CONFIG_DIR, "watches.yaml");
+
+// src/watches/parser.ts
+var log25 = createLogger("watches");
+
 // src/operations/commands/handler.ts
-var log24 = createLogger("commands");
-var sessionLog4 = createSessionLog(log24);
+var log26 = createLogger("commands");
+var sessionLog4 = createSessionLog(log26);
 // src/operations/suggestions/branch.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
-var log25 = createLogger("branch");
+var log27 = createLogger("branch");
 
 // src/operations/worktree/handler.ts
-var log26 = createLogger("worktree");
-var sessionLog5 = createSessionLog(log26);
+var log28 = createLogger("worktree");
+var sessionLog5 = createSessionLog(log28);
 // src/operations/events/handler.ts
-var log27 = createLogger("events");
-var sessionLog6 = createSessionLog(log27);
+var log29 = createLogger("events");
+var sessionLog6 = createSessionLog(log29);
 // src/operations/monitor/handler.ts
-var log28 = createLogger("monitor");
+var log30 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 // src/utils/websocket.ts
 var WS;
@@ -58127,7 +58306,7 @@ ${code}
 
 // src/platform/mattermost/upload.ts
 import { readFile } from "fs/promises";
-var log29 = createLogger("mm-upload");
+var log31 = createLogger("mm-upload");
 async function uploadFileMattermost(args) {
   const { url: url2, token, channelId, threadId, filePath, filename, caption } = args;
   const buffer = await readFile(filePath);
@@ -58135,7 +58314,7 @@ async function uploadFileMattermost(args) {
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
   const formData = new FormData;
   formData.append("files", new Blob([arrayBuffer]), filename);
-  log29.debug(`POST /files (${buffer.length} bytes, ${filename})`);
+  log31.debug(`POST /files (${buffer.length} bytes, ${filename})`);
   const uploadResponse = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -58159,7 +58338,7 @@ async function uploadFileMattermost(args) {
     root_id: resolvePostThreadId(threadId),
     file_ids: [fileInfo.id]
   };
-  log29.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
+  log31.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
   const postResponse = await fetch(postUrl, {
     method: "POST",
     headers: {
@@ -58653,7 +58832,7 @@ ${code}
 
 // src/platform/slack/upload.ts
 import { readFile as readFile2 } from "fs/promises";
-var log30 = createLogger("slack-upload");
+var log32 = createLogger("slack-upload");
 var DEFAULT_API_URL = "https://slack.com/api";
 async function uploadFileSlack(args) {
   const { botToken, channelId, threadTs, filePath, filename, caption } = args;
@@ -58661,7 +58840,7 @@ async function uploadFileSlack(args) {
   const buffer = await readFile2(filePath);
   const params = new URLSearchParams({ filename, length: String(buffer.length) });
   const step1Url = `${apiUrl}/files.getUploadURLExternal?${params.toString()}`;
-  log30.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
+  log32.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
   const step1Response = await fetch(step1Url, {
     method: "GET",
     headers: {
@@ -58679,7 +58858,7 @@ async function uploadFileSlack(args) {
   const uploadUrl = step1Data.upload_url;
   const fileId = step1Data.file_id;
   const arrayBuffer = buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
-  log30.debug(`POST <upload_url>`);
+  log32.debug(`POST <upload_url>`);
   const step2Response = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -58699,7 +58878,7 @@ async function uploadFileSlack(args) {
   if (caption !== undefined) {
     step3Body.initial_comment = caption;
   }
-  log30.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
+  log32.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
   const step3Response = await fetch(`${apiUrl}/files.completeUploadExternal`, {
     method: "POST",
     headers: {
@@ -58717,7 +58896,7 @@ async function uploadFileSlack(args) {
     throw new Error(`Slack completeUploadExternal error: ${step3Data.error || "unknown"}`);
   }
   if (!step3Data.ts) {
-    log30.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
+    log32.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
   }
   return { fileId, postId: step3Data.ts ?? fileId };
 }