claude-threads 1.25.0 → 1.26.0

package/dist/mcp/mcp-server.js

@@ -51087,7 +51087,8 @@ class PromptExecutor extends BaseExecutor {
     return {
       pendingContextPrompt: null,
       pendingExistingWorktreePrompt: null,
-      pendingUpdatePrompt: null
+      pendingUpdatePrompt: null,
+      pendingRoutinePrompt: null
     };
   }
   getInitialState() {
@@ -51097,14 +51098,16 @@ class PromptExecutor extends BaseExecutor {
     return {
       pendingContextPrompt: this.state.pendingContextPrompt ? { ...this.state.pendingContextPrompt } : null,
       pendingExistingWorktreePrompt: this.state.pendingExistingWorktreePrompt ? { ...this.state.pendingExistingWorktreePrompt } : null,
-      pendingUpdatePrompt: this.state.pendingUpdatePrompt ? { ...this.state.pendingUpdatePrompt } : null
+      pendingUpdatePrompt: this.state.pendingUpdatePrompt ? { ...this.state.pendingUpdatePrompt } : null,
+      pendingRoutinePrompt: this.state.pendingRoutinePrompt ? { ...this.state.pendingRoutinePrompt } : null
     };
   }
   hydrateState(persisted) {
     this.state = {
       pendingContextPrompt: persisted.pendingContextPrompt ?? null,
       pendingExistingWorktreePrompt: persisted.pendingExistingWorktreePrompt ?? null,
-      pendingUpdatePrompt: persisted.pendingUpdatePrompt ?? null
+      pendingUpdatePrompt: persisted.pendingUpdatePrompt ?? null,
+      pendingRoutinePrompt: null
     };
   }
   setPendingContextPrompt(prompt) {
@@ -51234,6 +51237,30 @@ class PromptExecutor extends BaseExecutor {
     }
     return true;
   }
+  setPendingRoutinePrompt(prompt) {
+    this.state.pendingRoutinePrompt = prompt;
+  }
+  hasPendingRoutinePrompt() {
+    return this.state.pendingRoutinePrompt !== null;
+  }
+  async handleRoutinePromptResponse(postId, approved, username, ctx) {
+    if (!this.state.pendingRoutinePrompt)
+      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)}`;
+    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 });
+    }
+    return true;
+  }
   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") {
@@ -51294,6 +51321,18 @@ class PromptExecutor extends BaseExecutor {
       ctx.logger.debug(`PromptExecutor: emoji ${emoji4} not valid for update prompt, ignoring`);
       return false;
     }
+    if (this.state.pendingRoutinePrompt?.postId === postId) {
+      if (isApprovalEmoji(emoji4)) {
+        ctx.logger.debug(`Routine prompt reaction from @${user}: approve`);
+        return this.handleRoutinePromptResponse(postId, true, user, ctx);
+      }
+      if (isDenialEmoji(emoji4)) {
+        ctx.logger.debug(`Routine prompt reaction from @${user}: discard`);
+        return this.handleRoutinePromptResponse(postId, false, user, ctx);
+      }
+      ctx.logger.debug(`PromptExecutor: emoji ${emoji4} not valid for routine prompt, ignoring`);
+      return false;
+    }
     ctx.logger.debug(`PromptExecutor: no pending prompt state matches postId=${postId.substring(0, 8)}`);
     return false;
   }
@@ -51910,6 +51949,9 @@ class MessageManager {
   clearPendingUpdatePrompt() {
     this.promptExecutor.clearPendingUpdatePrompt();
   }
+  setPendingRoutinePrompt(prompt) {
+    this.promptExecutor.setPendingRoutinePrompt(prompt);
+  }
   setPendingBugReport(report) {
     this.bugReportExecutor.setPendingBugReport(report);
   }
@@ -52184,6 +52226,9 @@ import { resolve as resolve2, dirname as dirname2 } from "path";
 import { homedir } from "os";
 
 // node_modules/js-yaml/dist/js-yaml.mjs
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
 var jsYaml = {};
 var loader = {};
 var common = {};
@@ -55287,6 +55332,7 @@ function requireJsYaml() {
   return jsYaml;
 }
 var jsYamlExports = requireJsYaml();
+var yaml = /* @__PURE__ */ getDefaultExportFromCjs(jsYamlExports);
 
 // src/config/index.ts
 var CONFIG_PATH = resolve2(homedir(), ".config", "claude-threads", "config.yaml");
@@ -55395,7 +55441,48 @@ function formatReleaseNotes(notes, formatter) {
 // src/utils/keep-alive.ts
 import { spawn } from "child_process";
 var log5 = createLogger("keepalive");
-
+function keepAliveSpawnSpec(platform, parentPid) {
+  switch (platform) {
+    case "darwin":
+      return {
+        command: "caffeinate",
+        args: ["-s", "-i", "-w", String(parentPid)],
+        stdio: "ignore"
+      };
+    case "linux":
+      return {
+        command: "systemd-inhibit",
+        args: [
+          "--what=sleep:idle:handle-lid-switch",
+          "--why=Claude Code session active",
+          "--mode=block",
+          "cat"
+        ],
+        stdio: ["pipe", "ignore", "ignore"]
+      };
+    default:
+      return null;
+  }
+}
+function linuxFallbackScript(parentPid) {
+  return `while kill -0 ${parentPid} 2>/dev/null; do xdg-screensaver reset 2>/dev/null || true; sleep 60; done`;
+}
+function windowsScript(parentPid) {
+  return `
+        Add-Type -TypeDefinition @"
+          using System;
+          using System.Runtime.InteropServices;
+          public class PowerState {
+            [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
+            public static extern uint SetThreadExecutionState(uint esFlags);
+          }
+"@
+        # ES_CONTINUOUS | ES_SYSTEM_REQUIRED
+        [PowerState]::SetThreadExecutionState(0x80000001) | Out-Null
+        # Keep running until killed or the parent process exits
+        while (Get-Process -Id ${parentPid} -ErrorAction SilentlyContinue) { Start-Sleep -Seconds 60 }
+      `;
+}
 class KeepAliveManager {
   activeSessionCount = 0;
   keepAliveProcess = null;
@@ -55472,8 +55559,11 @@ class KeepAliveManager {
   }
   startMacOSKeepAlive() {
     try {
-      this.keepAliveProcess = spawn("caffeinate", ["-s", "-i"], {
-        stdio: "ignore",
+      const spec = keepAliveSpawnSpec("darwin", process.pid);
+      if (!spec)
+        return;
+      this.keepAliveProcess = spawn(spec.command, spec.args, {
+        stdio: spec.stdio,
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
@@ -55493,14 +55583,11 @@ class KeepAliveManager {
   }
   startLinuxKeepAlive() {
     try {
-      this.keepAliveProcess = spawn("systemd-inhibit", [
-        "--what=sleep:idle:handle-lid-switch",
-        "--why=Claude Code session active",
-        "--mode=block",
-        "sleep",
-        "infinity"
-      ], {
-        stdio: "ignore",
+      const spec = keepAliveSpawnSpec("linux", process.pid);
+      if (!spec)
+        return;
+      this.keepAliveProcess = spawn(spec.command, spec.args, {
+        stdio: spec.stdio,
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
@@ -55522,10 +55609,7 @@ class KeepAliveManager {
   }
   startLinuxKeepAliveFallback() {
     try {
-      this.keepAliveProcess = spawn("bash", [
-        "-c",
-        `while true; do xdg-screensaver reset 2>/dev/null || true; sleep 60; done`
-      ], {
+      this.keepAliveProcess = spawn("bash", ["-c", linuxFallbackScript(process.pid)], {
         stdio: "ignore",
         detached: false
       });
@@ -55543,20 +55627,7 @@ class KeepAliveManager {
   }
   startWindowsKeepAlive() {
     try {
-      const script = `
-        Add-Type -TypeDefinition @"
-          using System;
-          using System.Runtime.InteropServices;
-          public class PowerState {
-            [DllImport("kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
-            public static extern uint SetThreadExecutionState(uint esFlags);
-          }
-"@
-        # ES_CONTINUOUS | ES_SYSTEM_REQUIRED
-        [PowerState]::SetThreadExecutionState(0x80000001) | Out-Null
-        # Keep running until killed
-        while ($true) { Start-Sleep -Seconds 60 }
-      `;
+      const script = windowsScript(process.pid);
       this.keepAliveProcess = spawn("powershell", ["-NoProfile", "-Command", script], {
         stdio: "ignore",
         detached: false,
@@ -56759,6 +56830,28 @@ var COMMAND_REGISTRY = [
       { name: "forget", description: "Remove one entry (by number or matching text), or all", args: "<n|text> | all" }
     ]
   },
+  {
+    command: "routine",
+    description: "Create a scheduled routine from a natural-language request (confirmed with \uD83D\uDC4D before saving)",
+    args: "<schedule, task>",
+    category: "settings",
+    audience: "user",
+    claudeNotes: "User decisions, not yours"
+  },
+  {
+    command: "routines",
+    description: "List scheduled routines; pause/resume/delete/run manage them",
+    args: "[pause|resume|delete|run <n>]",
+    category: "settings",
+    audience: "user",
+    claudeNotes: "User decisions, not yours",
+    subcommands: [
+      { name: "pause", description: "Pause a routine", args: "<n>" },
+      { name: "resume", description: "Resume a paused routine", args: "<n>" },
+      { name: "delete", description: "Delete a routine", args: "<n>" },
+      { name: "run", description: "Run a routine now, outside its schedule", args: "<n>" }
+    ]
+  },
   {
     command: "update",
     description: "Show auto-update status",
@@ -57033,6 +57126,30 @@ var handleMemory = async (ctx, args) => {
   await ctx.client.createPost(`⚠️ Usage: ${ctx.formatter.formatCode("!memory")} or ${ctx.formatter.formatCode("!memory forget <n|text>")} or ${ctx.formatter.formatCode("!memory forget all")}`, ctx.threadId);
   return { handled: true };
 };
+var handleRoutine = 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("!routine every weekday at 9:00, <task>")}`, ctx.threadId);
+    return { handled: true };
+  }
+  await ctx.sessionManager.createRoutine(ctx.threadId, args, ctx.username);
+  return { handled: true };
+};
+var handleRoutines = async (ctx, args) => {
+  if (ctx.commandContext === "first-message") {
+    return { handled: false };
+  }
+  if (!ctx.isAllowed) {
+    return { handled: true };
+  }
+  await ctx.sessionManager.manageRoutines(ctx.threadId, args, ctx.username);
+  return { handled: true };
+};
 var handleCd = async (ctx, args) => {
   if (!args) {
     return { handled: false };
@@ -57224,6 +57341,8 @@ handlers.set("kick", handleKick);
 handlers.set("github-email", handleGitHubEmail);
 handlers.set("remember", handleRemember);
 handlers.set("memory", handleMemory);
+handlers.set("routine", handleRoutine);
+handlers.set("routines", handleRoutines);
 handlers.set("cd", handleCd);
 handlers.set("permissions", handlePermissions);
 handlers.set("mentions", handleMentions);
@@ -57627,23 +57746,200 @@ var log20 = createLogger("gh-emails");
 var DEFAULT_CONFIG_DIR = join7(homedir5(), ".config", "claude-threads");
 var DEFAULT_FILE = join7(DEFAULT_CONFIG_DIR, "github-emails.yaml");
 
+// src/persistence/routines-store.ts
+import { existsSync as existsSync6, mkdirSync as mkdirSync2, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join8 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
+
+// src/persistence/atomic-file.ts
+import { chmodSync as chmodSync2, 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);
+  chmodSync2(file2, 384);
+}
+
+// src/persistence/routines-store.ts
+var log21 = createLogger("routines");
+var DEFAULT_CONFIG_DIR2 = join8(homedir6(), ".config", "claude-threads");
+var DEFAULT_FILE2 = join8(DEFAULT_CONFIG_DIR2, "routines.yaml");
+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 {
+  file;
+  configDir;
+  queue = new SerialQueue;
+  constructor(filePath) {
+    const effective = filePath ?? process.env.CLAUDE_THREADS_ROUTINES_PATH;
+    if (effective) {
+      this.file = effective;
+      this.configDir = join8(effective, "..");
+    } else {
+      this.file = DEFAULT_FILE2;
+      this.configDir = DEFAULT_CONFIG_DIR2;
+    }
+    if (!existsSync6(this.configDir)) {
+      mkdirSync2(this.configDir, { recursive: true, mode: 448 });
+    }
+  }
+  list(platformId) {
+    return this.loadRaw().routines[platformId] ?? [];
+  }
+  get(platformId, id) {
+    return this.list(platformId).find((r) => r.id === id);
+  }
+  add(platformId, routine, maxRoutines = DEFAULT_MAX_ROUTINES) {
+    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];
+      this.writeAtomic(data);
+      log21.info(`Routine "${full.name}" created on ${platformId} by @${full.createdBy}`);
+      return { ok: true, routine: full };
+    });
+  }
+  update(platformId, id, patch) {
+    return this.runExclusive(() => {
+      const data = this.loadRaw();
+      const routines = data.routines[platformId] ?? [];
+      const idx = routines.findIndex((r) => r.id === id);
+      if (idx < 0)
+        return;
+      routines[idx] = { ...routines[idx], ...patch };
+      this.writeAtomic(data);
+      return routines[idx];
+    });
+  }
+  remove(platformId, id) {
+    return this.runExclusive(() => {
+      const data = this.loadRaw();
+      const routines = data.routines[platformId] ?? [];
+      const idx = routines.findIndex((r) => r.id === id);
+      if (idx < 0)
+        return;
+      const [removed] = routines.splice(idx, 1);
+      if (routines.length === 0)
+        delete data.routines[platformId];
+      this.writeAtomic(data);
+      log21.info(`Routine "${removed.name}" removed from ${platformId}`);
+      return removed;
+    });
+  }
+  runExclusive(fn) {
+    return this.queue.run(fn);
+  }
+  loadRaw() {
+    if (!existsSync6(this.file)) {
+      return { version: STORE_VERSION, routines: {} };
+    }
+    try {
+      const parsed = yaml.load(readFileSync5(this.file, "utf-8"));
+      if (!parsed || typeof parsed !== "object") {
+        return { version: STORE_VERSION, routines: {} };
+      }
+      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 };
+    } catch (err) {
+      log21.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
+      return { version: STORE_VERSION, routines: {} };
+    }
+  }
+  writeAtomic(data) {
+    writeFileAtomic(this.file, yaml.dump(data, { sortKeys: true, lineWidth: -1 }));
+  }
+}
+
+// src/routines/parser.ts
+var log22 = createLogger("routines");
+
 // src/operations/commands/handler.ts
-var log21 = createLogger("commands");
-var sessionLog4 = createSessionLog(log21);
+var log23 = createLogger("commands");
+var sessionLog4 = createSessionLog(log23);
 // src/operations/suggestions/branch.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
 var execAsync2 = promisify2(exec2);
-var log22 = createLogger("branch");
+var log24 = createLogger("branch");
 
 // src/operations/worktree/handler.ts
-var log23 = createLogger("worktree");
-var sessionLog5 = createSessionLog(log23);
+var log25 = createLogger("worktree");
+var sessionLog5 = createSessionLog(log25);
 // src/operations/events/handler.ts
-var log24 = createLogger("events");
-var sessionLog6 = createSessionLog(log24);
+var log26 = createLogger("events");
+var sessionLog6 = createSessionLog(log26);
 // src/operations/monitor/handler.ts
-var log25 = createLogger("monitor");
+var log27 = createLogger("monitor");
 var DEFAULT_INTERVAL_MS = 60 * 1000;
 // src/utils/websocket.ts
 var WS;
@@ -57725,7 +58021,7 @@ ${code}
 
 // src/platform/mattermost/upload.ts
 import { readFile } from "fs/promises";
-var log26 = createLogger("mm-upload");
+var log28 = createLogger("mm-upload");
 async function uploadFileMattermost(args) {
   const { url: url2, token, channelId, threadId, filePath, filename, caption } = args;
   const buffer = await readFile(filePath);
@@ -57733,7 +58029,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);
-  log26.debug(`POST /files (${buffer.length} bytes, ${filename})`);
+  log28.debug(`POST /files (${buffer.length} bytes, ${filename})`);
   const uploadResponse = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -57757,7 +58053,7 @@ async function uploadFileMattermost(args) {
     root_id: threadId,
     file_ids: [fileInfo.id]
   };
-  log26.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
+  log28.debug(`POST /posts (file_ids=[${fileInfo.id}])`);
   const postResponse = await fetch(postUrl, {
     method: "POST",
     headers: {
@@ -58251,7 +58547,7 @@ ${code}
 
 // src/platform/slack/upload.ts
 import { readFile as readFile2 } from "fs/promises";
-var log27 = createLogger("slack-upload");
+var log29 = createLogger("slack-upload");
 var DEFAULT_API_URL = "https://slack.com/api";
 async function uploadFileSlack(args) {
   const { botToken, channelId, threadTs, filePath, filename, caption } = args;
@@ -58259,7 +58555,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()}`;
-  log27.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
+  log29.debug(`GET files.getUploadURLExternal (${buffer.length} bytes, ${filename})`);
   const step1Response = await fetch(step1Url, {
     method: "GET",
     headers: {
@@ -58277,7 +58573,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);
-  log27.debug(`POST <upload_url>`);
+  log29.debug(`POST <upload_url>`);
   const step2Response = await fetch(uploadUrl, {
     method: "POST",
     headers: {
@@ -58297,7 +58593,7 @@ async function uploadFileSlack(args) {
   if (caption !== undefined) {
     step3Body.initial_comment = caption;
   }
-  log27.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
+  log29.debug(`POST files.completeUploadExternal (file_id=${fileId}, thread_ts=${threadTs})`);
   const step3Response = await fetch(`${apiUrl}/files.completeUploadExternal`, {
     method: "POST",
     headers: {
@@ -58315,7 +58611,7 @@ async function uploadFileSlack(args) {
     throw new Error(`Slack completeUploadExternal error: ${step3Data.error || "unknown"}`);
   }
   if (!step3Data.ts) {
-    log27.warn(`Slack completeUploadExternal returned no ts; using fileId ${fileId} as postId. ` + `Do not use this id for updatePost/addReaction.`);
+    log29.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 };
 }

package/docs/CONFIGURATION.md

@@ -245,6 +245,65 @@ platforms:
   `CLAUDE_CODE_REMOTE` is set (unless `CLAUDE_CODE_REMOTE_MEMORY_DIR` is
   configured) — the repo layer will be inert in such environments.
 
+### Routines (`routines`, default: enabled)
+
+Scheduled recurring work, Claude Tag-style: a routine fires on its schedule
+as a **bot-initiated session thread** in the channel — a completely normal
+session (platform permission mode, account-pool balancing, channel memory,
+distillation) whose task is the routine's prompt.
+
+```yaml
+platforms:
+  - id: mattermost-main
+    type: mattermost
+    # ... credentials ...
+    routines: true              # default; `false` disables the scheduler + commands
+
+limits:
+  maxRoutines: 10               # per-platform cap (default 10)
+```
+
+**Creating** (natural language, confirmed before saving):
+
+```
+!routine every weekday at 9am, summarize the open review threads
+```
+
+A haiku pass parses the request into a structured schedule (presets: hourly /
+daily / weekdays / weekly — hourly is the floor), the bot posts the parsed
+result, and **nothing is saved until someone reacts 👍**. Timezones: name one
+explicitly ("9am Pacific"); otherwise the bot host's timezone is used and the
+confirmation says so.
+
+**Managing:**
+
+- `!routines` — numbered list with schedule, creator, and last-run status
+- `!routines pause|resume|delete <n>` — owner-gated
+- `!routines run <n>` — fire now, outside the schedule (platform-allowed
+  users only — not temporarily `!invite`d guests; does not consume the
+  period's scheduled fire)
+
+**Semantics & guardrails:**
+
+- Runs fire **as their creator** and are re-authorized on every fire — a
+  creator who loses platform authorization disables the routine (with a
+  channel notice), mirroring Claude Tag.
+- At most one fire per period (hour/day/week), evaluated on the wall clock in
+  the routine's timezone (DST-safe). A window missed entirely (bot offline)
+  is skipped, not back-filled.
+- 3 consecutive failed runs auto-disable the routine with a channel notice;
+  `!routines resume <n>` re-arms it.
+- Runs count against `MAX_SESSIONS`; at the limit a fire is retried within
+  its window and otherwise skipped.
+- **Each run starts a full Claude session on your subscription** — the
+  confirmation and `!routines` listing both say so.
+- Routines are scoped per platform instance (same privacy boundary as
+  memory) and stored at `~/.config/claude-threads/routines.yaml` (0600;
+  override with `CLAUDE_THREADS_ROUTINES_PATH`).
+- The natural-language parse uses one haiku `claude -p` call — the same
+  bot-process-credentials caveat as memory distillation applies in OAuth
+  account pools.
+
 ## Claude Accounts (optional, multi-account mode)
 
 By default every session spawns `claude` with the bot's own `process.env`, so they all share one subscription's token budget. Add a `claudeAccounts` block to spread load across multiple accounts. Omit the block entirely to stay in single-account mode (unchanged behavior).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-threads",
-  "version": "1.25.0",
+  "version": "1.26.0",
   "description": "Run Claude Code from Slack or Mattermost. Sessions stream live into threads where your whole team can watch and steer.",
   "main": "dist/index.js",
   "type": "module",