claude-threads 1.25.0 → 1.26.0

package/dist/index.js

@@ -12857,9 +12857,9 @@ GFS4: `);
       }
     }
     var fs$readdir = fs3.readdir;
-    fs3.readdir = readdir2;
+    fs3.readdir = readdir;
     var noReaddirOptionVersions = /^v[0-5]\./;
-    function readdir2(path2, options, cb) {
+    function readdir(path2, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
       var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path3, options2, cb2, startTime) {
@@ -14810,9 +14810,9 @@ GFS4: `);
       }
     }
     var fs$readdir = fs5.readdir;
-    fs5.readdir = readdir2;
+    fs5.readdir = readdir;
     var noReaddirOptionVersions = /^v[0-5]\./;
-    function readdir2(path6, options, cb) {
+    function readdir(path6, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
       var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir(path7, options2, cb2, startTime) {
@@ -20451,7 +20451,7 @@ var require_react_reconciler_development = __commonJS((exports, module) => {
       return hook.checkDCE ? true : false;
     }
     function setIsStrictModeForDevtools(newIsStrictMode) {
-      typeof log39 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
+      typeof log43 === "function" && unstable_setDisableYieldValue2(newIsStrictMode);
       if (injectedHook && typeof injectedHook.setStrictMode === "function")
         try {
           injectedHook.setStrictMode(rendererID, newIsStrictMode);
@@ -28535,7 +28535,7 @@ Check the render method of %s.`, getComponentNameFromFiber(current) || "Unknown"
     var fiberStack = [];
     var index$jscomp$0 = -1, emptyContextObject = {};
     Object.freeze(emptyContextObject);
-    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log39 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
+    var clz32 = Math.clz32 ? Math.clz32 : clz32Fallback, log$1 = Math.log, LN2 = Math.LN2, nextTransitionUpdateLane = 256, nextTransitionDeferredLane = 262144, nextRetryLane = 4194304, scheduleCallback$3 = Scheduler.unstable_scheduleCallback, cancelCallback$1 = Scheduler.unstable_cancelCallback, shouldYield = Scheduler.unstable_shouldYield, requestPaint = Scheduler.unstable_requestPaint, now$1 = Scheduler.unstable_now, ImmediatePriority = Scheduler.unstable_ImmediatePriority, UserBlockingPriority = Scheduler.unstable_UserBlockingPriority, NormalPriority$1 = Scheduler.unstable_NormalPriority, IdlePriority = Scheduler.unstable_IdlePriority, log43 = Scheduler.log, unstable_setDisableYieldValue2 = Scheduler.unstable_setDisableYieldValue, rendererID = null, injectedHook = null, hasLoggedError = false, isDevToolsPresent = typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== "undefined", lastResetTime = 0;
     if (typeof performance === "object" && typeof performance.now === "function") {
       var localPerformance = performance;
       var getCurrentTime = function() {
@@ -51226,6 +51226,14 @@ function resolveMemoryConfig(value, fieldPath) {
   console.warn(`Invalid ${fieldPath ?? "memory"} config: expected boolean or {enabled, repoLayer, channelLayer, distillation}, got ${JSON.stringify(value)} — using defaults`);
   return DEFAULT_MEMORY_CONFIG;
 }
+function resolveRoutinesEnabled(value, fieldPath) {
+  if (value === undefined || value === null || value === true)
+    return true;
+  if (value === false)
+    return false;
+  console.warn(`Invalid ${fieldPath ?? "routines"} config: expected boolean, got ${JSON.stringify(value)} — routines stay enabled`);
+  return true;
+}
 var LIMITS_DEFAULTS = {
   maxSessions: 5,
   sessionTimeoutMinutes: 30,
@@ -51234,7 +51242,8 @@ var LIMITS_DEFAULTS = {
   maxWorktreeAgeHours: 24,
   cleanupWorktrees: true,
   permissionTimeoutSeconds: 120,
-  flushDelayMs: 500
+  flushDelayMs: 500,
+  maxRoutines: 10
 };
 function resolveLimits(limits) {
   const envMaxSessions = process.env.MAX_SESSIONS ? parseInt(process.env.MAX_SESSIONS, 10) : undefined;
@@ -51247,7 +51256,8 @@ function resolveLimits(limits) {
     maxWorktreeAgeHours: limits?.maxWorktreeAgeHours ?? LIMITS_DEFAULTS.maxWorktreeAgeHours,
     cleanupWorktrees: limits?.cleanupWorktrees ?? LIMITS_DEFAULTS.cleanupWorktrees,
     permissionTimeoutSeconds: limits?.permissionTimeoutSeconds ?? LIMITS_DEFAULTS.permissionTimeoutSeconds,
-    flushDelayMs: limits?.flushDelayMs ?? LIMITS_DEFAULTS.flushDelayMs
+    flushDelayMs: limits?.flushDelayMs ?? LIMITS_DEFAULTS.flushDelayMs,
+    maxRoutines: limits?.maxRoutines ?? LIMITS_DEFAULTS.maxRoutines
   };
 }
 function resolvePermissionMode(opts) {
@@ -56178,11 +56188,570 @@ async function resolveSessionMemory(memoryStore, memoryConfig, platformId, worki
   }
 }
 
-// src/claude/account-pool.ts
+// src/persistence/routines-store.ts
+import { existsSync as existsSync8, mkdirSync as mkdirSync5, readFileSync as readFileSync7 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
+import { randomUUID as randomUUID2 } from "crypto";
 init_logger();
 
-// src/claude/usage-probe.ts
-init_spawn();
+// src/persistence/atomic-file.ts
+import { chmodSync as chmodSync5, renameSync as renameSync4, writeFileSync as writeFileSync5 } 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(file, content) {
+  const tempFile = `${file}.tmp`;
+  writeFileSync5(tempFile, content, { encoding: "utf-8", mode: 384 });
+  renameSync4(tempFile, file);
+  chmodSync5(file, 384);
+}
+
+// src/persistence/routines-store.ts
+var log10 = createLogger("routines");
+var DEFAULT_CONFIG_DIR3 = join7(homedir6(), ".config", "claude-threads");
+var DEFAULT_FILE2 = join7(DEFAULT_CONFIG_DIR3, "routines.yaml");
+var STORE_VERSION3 = 1;
+var MAX_CONSECUTIVE_FAILURES = 3;
+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;
+}
+function describeSchedule(schedule) {
+  const WEEKDAYS = ["", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];
+  switch (schedule.preset) {
+    case "hourly":
+      return `hourly (${schedule.timezone})`;
+    case "daily":
+      return `daily at ${schedule.time} (${schedule.timezone})`;
+    case "weekdays":
+      return `weekdays at ${schedule.time} (${schedule.timezone})`;
+    case "weekly":
+      return `weekly on ${WEEKDAYS[schedule.weekday ?? 0] || "?"} at ${schedule.time} (${schedule.timezone})`;
+  }
+}
+
+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 = join7(effective, "..");
+    } else {
+      this.file = DEFAULT_FILE2;
+      this.configDir = DEFAULT_CONFIG_DIR3;
+    }
+    if (!existsSync8(this.configDir)) {
+      mkdirSync5(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);
+      log10.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);
+      log10.info(`Routine "${removed.name}" removed from ${platformId}`);
+      return removed;
+    });
+  }
+  runExclusive(fn) {
+    return this.queue.run(fn);
+  }
+  loadRaw() {
+    if (!existsSync8(this.file)) {
+      return { version: STORE_VERSION3, routines: {} };
+    }
+    try {
+      const parsed = yaml.load(readFileSync7(this.file, "utf-8"));
+      if (!parsed || typeof parsed !== "object") {
+        return { version: STORE_VERSION3, 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_VERSION3, routines };
+    } catch (err) {
+      log10.warn(`Failed to read ${this.file}: ${err.message} — starting empty`);
+      return { version: STORE_VERSION3, routines: {} };
+    }
+  }
+  writeAtomic(data) {
+    writeFileAtomic(this.file, yaml.dump(data, { sortKeys: true, lineWidth: -1 }));
+  }
+}
+
+// src/routines/scheduler.ts
+init_logger();
+var log11 = createLogger("routines");
+var DEFAULT_INTERVAL_MS = 60 * 1000;
+var FIRE_WINDOW_MS = 5 * 60 * 1000;
+var WEEKDAY_TO_ISO = {
+  Mon: 1,
+  Tue: 2,
+  Wed: 3,
+  Thu: 4,
+  Fri: 5,
+  Sat: 6,
+  Sun: 7
+};
+function getLocalParts(date, timeZone) {
+  const fmt = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    weekday: "short",
+    hour12: false
+  });
+  const parts = {};
+  for (const p of fmt.formatToParts(date)) {
+    parts[p.type] = p.value;
+  }
+  return {
+    year: parseInt(parts.year, 10),
+    month: parseInt(parts.month, 10),
+    day: parseInt(parts.day, 10),
+    hour: parseInt(parts.hour, 10) % 24,
+    minute: parseInt(parts.minute, 10),
+    isoWeekday: WEEKDAY_TO_ISO[parts.weekday] ?? 0
+  };
+}
+function periodKey(routine, date) {
+  const p = getLocalParts(date, routine.schedule.timezone);
+  const day = `${p.year}-${String(p.month).padStart(2, "0")}-${String(p.day).padStart(2, "0")}`;
+  return routine.schedule.preset === "hourly" ? `${day}T${String(p.hour).padStart(2, "0")}` : day;
+}
+function isInFireWindow(routine, now) {
+  const { schedule } = routine;
+  const p = getLocalParts(now, schedule.timezone);
+  if (schedule.preset === "hourly") {
+    return p.minute * 60 * 1000 < FIRE_WINDOW_MS;
+  }
+  if (schedule.preset === "weekdays" && (p.isoWeekday < 1 || p.isoWeekday > 5))
+    return false;
+  if (schedule.preset === "weekly" && p.isoWeekday !== schedule.weekday)
+    return false;
+  const [hh, mm] = (schedule.time ?? "00:00").split(":").map((s) => parseInt(s, 10));
+  const nowMs = (p.hour * 60 + p.minute) * 60 * 1000;
+  const schedMs = (hh * 60 + mm) * 60 * 1000;
+  if (nowMs >= schedMs && nowMs - schedMs < FIRE_WINDOW_MS)
+    return true;
+  const prev = getLocalParts(new Date(now.getTime() - FIRE_WINDOW_MS), schedule.timezone);
+  const sameDay = prev.year === p.year && prev.month === p.month && prev.day === p.day;
+  const prevMs = (prev.hour * 60 + prev.minute) * 60 * 1000;
+  return sameDay && prevMs < schedMs && nowMs >= schedMs;
+}
+function isRoutineDue(routine, now) {
+  if (!routine.enabled)
+    return false;
+  if (!isInFireWindow(routine, now))
+    return false;
+  if (routine.lastRunAt) {
+    const last = new Date(routine.lastRunAt);
+    if (!Number.isNaN(last.getTime()) && periodKey(routine, last) === periodKey(routine, now)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+class RoutineScheduler {
+  opts;
+  intervalMs;
+  timer = null;
+  ticking = false;
+  constructor(opts) {
+    this.opts = opts;
+    this.intervalMs = opts.intervalMs ?? DEFAULT_INTERVAL_MS;
+  }
+  start() {
+    if (this.timer)
+      return;
+    const safeTick = () => this.tick(new Date).catch((err) => {
+      log11.error(`Routine scheduler tick failed: ${err.message}`);
+    });
+    this.timer = setInterval(safeTick, this.intervalMs);
+    safeTick();
+    log11.debug(`Routine scheduler started (interval: ${this.intervalMs / 1000}s)`);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+  async tick(now) {
+    if (this.ticking)
+      return;
+    this.ticking = true;
+    try {
+      for (const platformId of this.opts.listPlatformIds()) {
+        if (!this.opts.isRoutinesEnabled(platformId))
+          continue;
+        for (const routine of this.opts.store.list(platformId)) {
+          if (!isRoutineDue(routine, now))
+            continue;
+          await this.fire(platformId, routine, now);
+        }
+      }
+    } finally {
+      this.ticking = false;
+    }
+  }
+  async fire(platformId, routine, now, anchorPeriod = true) {
+    let status;
+    try {
+      status = await this.opts.fireRoutine(platformId, routine);
+    } catch (err) {
+      log11.warn(`Routine "${routine.name}" (${platformId}) failed: ${err.message}`);
+      status = "failed";
+    }
+    try {
+      if (status === "unauthorized") {
+        await this.opts.store.update(platformId, routine.id, { enabled: false, lastRunStatus: "failed" });
+        await this.opts.notifyDisabled(platformId, routine, `its creator @${routine.createdBy} is no longer authorized on this platform`);
+      } else if (status === "skipped") {
+        await this.opts.store.update(platformId, routine.id, { lastRunStatus: "skipped" });
+      } else if (!anchorPeriod) {
+        await this.opts.store.update(platformId, routine.id, { lastRunStatus: status });
+      } else {
+        const failures = status === "failed" ? routine.consecutiveFailures + 1 : 0;
+        await this.opts.store.update(platformId, routine.id, {
+          lastRunAt: now.toISOString(),
+          lastRunStatus: status,
+          consecutiveFailures: failures
+        });
+        if (failures >= MAX_CONSECUTIVE_FAILURES) {
+          await this.opts.store.update(platformId, routine.id, { enabled: false });
+          await this.opts.notifyDisabled(platformId, routine, `${failures} consecutive runs failed`);
+        }
+      }
+    } catch (err) {
+      log11.error(`Routine "${routine.name}" (${platformId}) bookkeeping failed: ${err.message}`);
+    }
+    return status;
+  }
+}
+
+// src/session/authorization.ts
+function isAuthorizedForSession(check) {
+  const { username, platform, sessionAllowedUsers } = check;
+  if (!username || username === "unknown") {
+    return false;
+  }
+  if (platform.isUserAllowed(username)) {
+    return true;
+  }
+  return sessionAllowedUsers?.has(username) ?? false;
+}
+
+// src/session/lifecycle-fsm.ts
+init_logger();
+var log12 = createLogger("fsm");
+var ALLOWED_TRANSITIONS = {
+  starting: new Set(["active", "paused", "interrupted", "cancelling", "restarting"]),
+  active: new Set([
+    "active",
+    "processing",
+    "paused",
+    "interrupted",
+    "restarting",
+    "cancelling",
+    "ending"
+  ]),
+  processing: new Set([
+    "active",
+    "paused",
+    "interrupted",
+    "restarting",
+    "cancelling"
+  ]),
+  paused: new Set(["active", "cancelling", "restarting"]),
+  interrupted: new Set(["active", "cancelling", "restarting", "paused"]),
+  restarting: new Set(["active", "paused", "cancelling"]),
+  cancelling: new Set(["ending"]),
+  ending: new Set
+};
+function checkTransition(from, to, sessionId) {
+  const allowed = ALLOWED_TRANSITIONS[from];
+  if (allowed.has(to))
+    return;
+  const msg = `illegal lifecycle transition ${from} -> ${to}`;
+  const payload = {
+    event: "fsm.illegal_transition",
+    from,
+    to,
+    sessionId
+  };
+  if (process.env.CLAUDE_THREADS_FSM_STRICT === "1") {
+    throw new Error(`${msg} (sessionId=${sessionId})`);
+  }
+  log12.warn(msg, payload);
+}
+
+// src/session/timer-manager.ts
+function createSessionTimers() {
+  return {
+    updateTimer: null,
+    typingTimer: null,
+    statusBarTimer: null
+  };
+}
+function clearAllTimers(timers) {
+  if (timers.updateTimer) {
+    clearTimeout(timers.updateTimer);
+    timers.updateTimer = null;
+  }
+  if (timers.typingTimer) {
+    clearInterval(timers.typingTimer);
+    timers.typingTimer = null;
+  }
+  if (timers.statusBarTimer) {
+    clearInterval(timers.statusBarTimer);
+    timers.statusBarTimer = null;
+  }
+}
+
+// src/session/types.ts
+function createSessionLifecycle() {
+  return {
+    state: "starting",
+    resumeFailCount: 0,
+    hasClaudeResponded: false
+  };
+}
+function createResumedLifecycle(resumeFailCount = 0) {
+  return {
+    state: "active",
+    resumeFailCount,
+    hasClaudeResponded: true
+  };
+}
+function isSessionRestarting(session) {
+  return session.lifecycle.state === "restarting";
+}
+function isSessionCancelled(session) {
+  return session.lifecycle.state === "cancelling";
+}
+function transitionTo(session, newState) {
+  checkTransition(session.lifecycle.state, newState, session.sessionId);
+  session.lifecycle.state = newState;
+}
+function markClaudeResponded(session) {
+  session.lifecycle.hasClaudeResponded = true;
+  if (session.lifecycle.state === "starting") {
+    session.lifecycle.state = "active";
+  }
+}
+function getSessionStatus(session) {
+  if (session.isProcessing) {
+    return session.lifecycle.hasClaudeResponded ? "active" : "starting";
+  }
+  return "idle";
+}
+
+// src/mcp/decision-bridge.ts
+import { createServer, createConnection } from "node:net";
+import { tmpdir } from "node:os";
+import { join as join8 } from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+import { mkdtempSync } from "node:fs";
+import { rm } from "node:fs/promises";
+
+class BridgeUnavailableError extends Error {
+}
+function bridgeSocketPath() {
+  if (process.platform === "win32") {
+    return `\\\\.\\pipe\\ctb-${randomUUID3()}`;
+  }
+  const dir = mkdtempSync(join8(tmpdir(), "ctb-"));
+  return join8(dir, "b.sock");
+}
+
+class DecisionBridgeServer {
+  server;
+  path;
+  liveSockets = new Set;
+  constructor(server, path2) {
+    this.server = server;
+    this.path = path2;
+  }
+  static async create(handler) {
+    const path2 = bridgeSocketPath();
+    const liveSockets = new Set;
+    const server = createServer((socket) => {
+      liveSockets.add(socket);
+      socket.once("close", () => liveSockets.delete(socket));
+      let buffer = "";
+      const aborter = new AbortController;
+      let responded = false;
+      socket.on("data", (chunk) => {
+        buffer += chunk.toString("utf8");
+        const newline = buffer.indexOf(`
+`);
+        if (newline === -1)
+          return;
+        const line = buffer.slice(0, newline);
+        buffer = "";
+        let request;
+        try {
+          request = JSON.parse(line);
+        } catch {
+          responded = true;
+          socket.end(JSON.stringify({ behavior: "deny", message: "Malformed bridge request" }) + `
+`);
+          return;
+        }
+        handler(request, aborter.signal).then((response) => {
+          responded = true;
+          socket.end(JSON.stringify(response) + `
+`);
+        }).catch((err) => {
+          responded = true;
+          if (err instanceof BridgeUnavailableError) {
+            socket.destroy();
+            return;
+          }
+          socket.end(JSON.stringify({
+            behavior: "deny",
+            message: `Bridge handler failed: ${err instanceof Error ? err.message : String(err)}`
+          }) + `
+`);
+        });
+      });
+      socket.on("close", () => {
+        if (!responded)
+          aborter.abort();
+      });
+      socket.on("error", () => {});
+    });
+    try {
+      await new Promise((resolve4, reject) => {
+        server.once("error", reject);
+        server.listen(path2, () => {
+          server.removeListener("error", reject);
+          resolve4();
+        });
+      });
+    } catch (err) {
+      if (process.platform !== "win32") {
+        await rm(join8(path2, ".."), { recursive: true, force: true }).catch(() => {});
+      }
+      throw err;
+    }
+    const bridge = new DecisionBridgeServer(server, path2);
+    bridge.liveSockets = liveSockets;
+    return bridge;
+  }
+  async close() {
+    for (const socket of this.liveSockets)
+      socket.destroy();
+    await new Promise((resolve4) => this.server.close(() => resolve4()));
+    if (process.platform !== "win32") {
+      await rm(join8(this.path, ".."), { recursive: true, force: true }).catch(() => {});
+    }
+  }
+}
 
 // src/claude/cli.ts
 init_spawn();
@@ -56190,9 +56759,9 @@ init_logger();
 import { EventEmitter as EventEmitter2 } from "events";
 import { resolve as resolve4, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
-import { existsSync as existsSync8, readFileSync as readFileSync7, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync as writeFileSync5 } from "fs";
-import { tmpdir } from "os";
-import { join as join7 } from "path";
+import { existsSync as existsSync9, readFileSync as readFileSync8, watchFile, unwatchFile, unlinkSync, statSync, readdirSync, writeFileSync as writeFileSync6 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join9 } from "path";
 
 // src/mcp/outbound-env.ts
 var OUTBOUND_ENV = {
@@ -56283,25 +56852,25 @@ function parseRateLimitEvent(event, now = Date.now()) {
 }
 
 // src/claude/cli.ts
-var log10 = createLogger("claude");
+var log13 = createLogger("claude");
 function cleanupBrowserBridgeSockets() {
   try {
-    const tempDir = tmpdir();
+    const tempDir = tmpdir2();
     const files = readdirSync(tempDir);
     for (const file of files) {
       if (file.startsWith("claude-mcp-browser-bridge-")) {
-        const filePath = join7(tempDir, file);
+        const filePath = join9(tempDir, file);
         try {
           const stats = statSync(filePath);
           if (stats.isSocket()) {
             unlinkSync(filePath);
-            log10.debug(`Removed stale browser bridge socket: ${file}`);
+            log13.debug(`Removed stale browser bridge socket: ${file}`);
           }
         } catch {}
       }
     }
   } catch (err) {
-    log10.debug(`Browser bridge cleanup failed: ${err}`);
+    log13.debug(`Browser bridge cleanup failed: ${err}`);
   }
 }
 function buildClaudeChildEnv(parentEnv, account, opts) {
@@ -56359,9 +56928,9 @@ function materializeMcpConfig(config, sessionId, opts = {}) {
   if (opts.inline) {
     return { mode: "inline", value: JSON.stringify(config) };
   }
-  const dir = opts.tmpDirOverride ?? tmpdir();
-  const path2 = join7(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
-  writeFileSync5(path2, JSON.stringify(config), { mode: 384 });
+  const dir = opts.tmpDirOverride ?? tmpdir2();
+  const path2 = join9(dir, `claude-threads-mcp-${sessionId ?? process.pid}-${Date.now()}.json`);
+  writeFileSync6(path2, JSON.stringify(config), { mode: 384 });
   return { mode: "file", path: path2 };
 }
 function buildPermissionArgs(opts) {
@@ -56461,8 +57030,8 @@ class ClaudeCli extends EventEmitter2 {
     if (!this.statusFilePath)
       return null;
     try {
-      if (existsSync8(this.statusFilePath)) {
-        const data = readFileSync7(this.statusFilePath, "utf8");
+      if (existsSync9(this.statusFilePath)) {
+        const data = readFileSync8(this.statusFilePath, "utf8");
         this.lastStatusData = JSON.parse(data);
       }
     } catch (err) {
@@ -56489,7 +57058,7 @@ class ClaudeCli extends EventEmitter2 {
     if (this.statusFilePath) {
       unwatchFile(this.statusFilePath);
       try {
-        if (existsSync8(this.statusFilePath)) {
+        if (existsSync9(this.statusFilePath)) {
           unlinkSync(this.statusFilePath);
         }
       } catch {}
@@ -56543,7 +57112,7 @@ class ClaudeCli extends EventEmitter2 {
     }
     let statusLineCommand;
     if (this.options.sessionId) {
-      this.statusFilePath = join7(tmpdir(), `claude-threads-status-${this.options.sessionId}.json`);
+      this.statusFilePath = join9(tmpdir2(), `claude-threads-status-${this.options.sessionId}.json`);
       const statusLineWriterPath = this.getStatusLineWriterPath();
       const runtime = runtimeForScriptPath(statusLineWriterPath);
       statusLineCommand = `${runtime} ${statusLineWriterPath} ${this.options.sessionId}`;
@@ -56780,15 +57349,15 @@ class ClaudeCli extends EventEmitter2 {
     const __filename2 = fileURLToPath3(import.meta.url);
     const __dirname4 = dirname6(__filename2);
     const bundledPath = resolve4(__dirname4, "mcp", "mcp-server.js");
-    if (existsSync8(bundledPath)) {
+    if (existsSync9(bundledPath)) {
       return bundledPath;
     }
     const sourceLayoutPath = resolve4(__dirname4, "..", "mcp", "mcp-server.js");
-    if (existsSync8(sourceLayoutPath)) {
+    if (existsSync9(sourceLayoutPath)) {
       return sourceLayoutPath;
     }
     const tsPath = resolve4(__dirname4, "..", "mcp", "mcp-server.ts");
-    if (existsSync8(tsPath)) {
+    if (existsSync9(tsPath)) {
       return tsPath;
     }
     return sourceLayoutPath;
@@ -56797,288 +57366,28 @@ class ClaudeCli extends EventEmitter2 {
     const __filename2 = fileURLToPath3(import.meta.url);
     const __dirname4 = dirname6(__filename2);
     const bundledPath = resolve4(__dirname4, "statusline", "writer.js");
-    if (existsSync8(bundledPath)) {
+    if (existsSync9(bundledPath)) {
       return bundledPath;
     }
     const sourceLayoutPath = resolve4(__dirname4, "..", "statusline", "writer.js");
-    if (existsSync8(sourceLayoutPath)) {
+    if (existsSync9(sourceLayoutPath)) {
       return sourceLayoutPath;
     }
     const tsPath = resolve4(__dirname4, "..", "statusline", "writer.ts");
-    if (existsSync8(tsPath)) {
+    if (existsSync9(tsPath)) {
       return tsPath;
     }
     return sourceLayoutPath;
   }
 }
 
-// src/claude/usage-probe.ts
-init_logger();
-var log11 = createLogger("usage-probe");
-var DEFAULT_USAGE_PROBE_TIMEOUT_MS = 30000;
-function parseUsageOutput(text) {
-  if (!text)
-    return null;
-  const sessionMatch = text.match(/Current session:\s*(\d+)%\s*used(?:\s*·\s*resets\s*([^\n]+?))?\s*(?:\n|$)/i);
-  const weekAllMatch = text.match(/Current week(?: \(all models\))?:\s*(\d+)%\s*used(?:\s*·\s*resets\s*([^\n]+?))?\s*(?:\n|$)/i);
-  if (!sessionMatch && !weekAllMatch)
-    return null;
-  const sessionPct = sessionMatch ? clampPct(Number(sessionMatch[1])) : 0;
-  const weekAllModelsPct = weekAllMatch ? clampPct(Number(weekAllMatch[1])) : 0;
-  let weekPerModelPct = null;
-  const perModelRe = /Current week \((?!all models\))[^)]+\):\s*(\d+)%\s*used/gi;
-  for (const m of text.matchAll(perModelRe)) {
-    const pct = clampPct(Number(m[1]));
-    weekPerModelPct = weekPerModelPct === null ? pct : Math.max(weekPerModelPct, pct);
-  }
-  return {
-    sessionPct,
-    weekAllModelsPct,
-    weekPerModelPct,
-    sessionResetsAt: sessionMatch?.[2]?.trim() || null,
-    weekResetsAt: weekAllMatch?.[2]?.trim() || null
-  };
-}
-function usageLoadScore(usage) {
-  return Math.max(usage.sessionPct, usage.weekAllModelsPct, usage.weekPerModelPct ?? 0);
-}
-function clampPct(n) {
-  if (!Number.isFinite(n))
-    return 0;
-  return Math.max(0, Math.min(100, Math.round(n)));
-}
-async function probeAccountUsage(account, opts = {}) {
-  const timeoutMs = opts.timeoutMs ?? DEFAULT_USAGE_PROBE_TIMEOUT_MS;
-  const claudePath = getClaudePath();
-  const env = buildClaudeChildEnv(process.env, account);
-  return new Promise((resolve5) => {
-    let settled = false;
-    const finish = (value) => {
-      if (settled)
-        return;
-      settled = true;
-      clearTimeout(timer);
-      resolve5(value);
-    };
-    let child;
-    try {
-      child = crossSpawn(claudePath, ["-p", "/usage", "--output-format", "json"], {
-        env,
-        stdio: ["ignore", "pipe", "pipe"]
-      });
-    } catch (err) {
-      log11.warn(`Failed to spawn /usage probe for "${account.id}": ${err}`);
-      resolve5(null);
-      return;
-    }
-    const timer = setTimeout(() => {
-      log11.warn(`/usage probe for "${account.id}" timed out after ${timeoutMs}ms`);
-      try {
-        child.kill("SIGKILL");
-      } catch {}
-      finish(null);
-    }, timeoutMs);
-    let stdout = "";
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr?.on("data", () => {});
-    child.on("error", (err) => {
-      log11.warn(`/usage probe for "${account.id}" errored: ${err}`);
-      finish(null);
-    });
-    child.on("close", () => {
-      const usage = extractUsage(stdout);
-      if (!usage) {
-        log11.debug(`/usage probe for "${account.id}" returned no parseable usage`);
-      }
-      finish(usage);
-    });
-  });
-}
-function extractUsage(stdout) {
-  const trimmed = stdout.trim();
-  if (!trimmed)
-    return null;
-  let text = trimmed;
-  try {
-    const parsed = JSON.parse(trimmed);
-    if (typeof parsed.result === "string") {
-      text = parsed.result;
-    }
-  } catch {}
-  return parseUsageOutput(text);
-}
-
-// src/claude/account-pool.ts
-var log12 = createLogger("account-pool");
-var ACTIVE_SESSION_LOAD_PENALTY = 5;
-function hashThreadId(threadId) {
-  let h = 2166136261;
-  for (let i = 0;i < threadId.length; i++) {
-    h ^= threadId.charCodeAt(i);
-    h = Math.imul(h, 16777619);
-  }
-  return h >>> 0;
-}
-
-class AccountPool {
-  accounts;
-  byId;
-  orderIndex;
-  activeCounts = new Map;
-  coolingUntil = new Map;
-  usage = new Map;
-  rrCursor = 0;
-  constructor(accounts) {
-    this.accounts = (accounts ?? []).filter((acc) => {
-      const hasAuth = !!acc.home || !!acc.apiKey;
-      if (!hasAuth) {
-        log12.warn(`Claude account ${acc.id} has neither home nor apiKey — ignoring`);
-        return false;
-      }
-      if (acc.home && acc.apiKey) {
-        log12.warn(`Claude account ${acc.id} has both home and apiKey set — must choose one; ignoring`);
-        return false;
-      }
-      return true;
-    });
-    this.byId = new Map(this.accounts.map((acc) => [acc.id, acc]));
-    this.orderIndex = new Map(this.accounts.map((acc, i) => [acc.id, i]));
-    for (const acc of this.accounts) {
-      this.activeCounts.set(acc.id, 0);
-      this.usage.set(acc.id, null);
-    }
-  }
-  get isEmpty() {
-    return this.accounts.length === 0;
-  }
-  get size() {
-    return this.accounts.length;
-  }
-  get all() {
-    return this.accounts;
-  }
-  acquire(preferredId, threadId, opts) {
-    if (this.isEmpty)
-      return null;
-    if (preferredId) {
-      const preferred = this.byId.get(preferredId);
-      if (preferred) {
-        this.incrementActive(preferred.id);
-        return preferred;
-      }
-      log12.warn(`Preferred account "${preferredId}" not in pool — falling back to usage balancing`);
-    }
-    const now = Date.now();
-    const n = this.accounts.length;
-    if (threadId && !opts?.balanceByUsage) {
-      const sticky = this.accounts[hashThreadId(threadId) % n];
-      const cooling = this.coolingUntil.get(sticky.id) ?? 0;
-      if (cooling <= now) {
-        this.incrementActive(sticky.id);
-        return sticky;
-      }
-    }
-    const chosen = this.selectLeastLoaded(now);
-    if (!chosen) {
-      log12.warn(`All ${n} accounts are in rate-limit cooldown`);
-      return null;
-    }
-    this.incrementActive(chosen.id);
-    return chosen;
-  }
-  selectLeastLoaded(now) {
-    const n = this.accounts.length;
-    let best = null;
-    let bestScore = Number.POSITIVE_INFINITY;
-    let bestIdx = -1;
-    for (let k = 0;k < n; k++) {
-      const idx = (this.rrCursor + k) % n;
-      const acc = this.accounts[idx];
-      if ((this.coolingUntil.get(acc.id) ?? 0) > now)
-        continue;
-      const score = this.effectiveLoad(acc.id);
-      if (best === null || score < bestScore) {
-        best = acc;
-        bestScore = score;
-        bestIdx = idx;
-      }
-    }
-    if (bestIdx >= 0)
-      this.rrCursor = (bestIdx + 1) % n;
-    return best;
-  }
-  loadScore(accountId) {
-    const u = this.usage.get(accountId);
-    return u ? usageLoadScore(u) : Number.POSITIVE_INFINITY;
-  }
-  effectiveLoad(accountId) {
-    const base = this.loadScore(accountId);
-    const active = this.activeCounts.get(accountId) ?? 0;
-    return base + ACTIVE_SESSION_LOAD_PENALTY * active;
-  }
-  release(accountId) {
-    const current = this.activeCounts.get(accountId);
-    if (current === undefined)
-      return;
-    this.activeCounts.set(accountId, Math.max(0, current - 1));
-  }
-  setUsage(accountId, usage) {
-    if (!this.byId.has(accountId))
-      return;
-    this.usage.set(accountId, usage);
-    if (usage) {
-      log12.debug(`Account "${accountId}" usage: ${usageLoadScore(usage)}% (load score)`);
-    }
-  }
-  markCooling(accountId, untilEpochMs) {
-    if (!this.byId.has(accountId)) {
-      log12.warn(`markCooling called for unknown account "${accountId}"`);
-      return;
-    }
-    const existing = this.coolingUntil.get(accountId) ?? 0;
-    if (untilEpochMs > existing) {
-      this.coolingUntil.set(accountId, untilEpochMs);
-      const minutes = Math.ceil((untilEpochMs - Date.now()) / 60000);
-      log12.info(`Account "${accountId}" cooling for ~${minutes}min`);
-    }
-  }
-  get(accountId) {
-    return this.byId.get(accountId);
-  }
-  status() {
-    const now = Date.now();
-    return this.accounts.map((acc) => {
-      const cooling = this.coolingUntil.get(acc.id) ?? 0;
-      const usage = this.usage.get(acc.id) ?? null;
-      return {
-        id: acc.id,
-        displayName: acc.displayName ?? acc.id,
-        activeSessions: this.activeCounts.get(acc.id) ?? 0,
-        coolingUntil: cooling > now ? cooling : null,
-        usagePercent: usage ? usageLoadScore(usage) : null
-      };
-    });
-  }
-  incrementActive(accountId) {
-    this.activeCounts.set(accountId, (this.activeCounts.get(accountId) ?? 0) + 1);
-  }
-}
-
-// src/cleanup/scheduler.ts
-init_logger();
-import { existsSync as existsSync10 } from "fs";
-import { readdir, rm } from "fs/promises";
-import { join as join9 } from "path";
-
 // src/persistence/thread-logger.ts
 init_logger();
-import { existsSync as existsSync9, mkdirSync as mkdirSync5, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync8, chmodSync as chmodSync5 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join8, dirname as dirname7 } from "path";
-var log13 = createLogger("thread-log");
-var LOGS_BASE_DIR = join8(homedir6(), ".claude-threads", "logs");
+import { existsSync as existsSync10, mkdirSync as mkdirSync6, appendFileSync, readdirSync as readdirSync2, statSync as statSync2, unlinkSync as unlinkSync2, rmdirSync, readFileSync as readFileSync9, chmodSync as chmodSync6 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join10, dirname as dirname7 } from "path";
+var log14 = createLogger("thread-log");
+var LOGS_BASE_DIR = join10(homedir7(), ".claude-threads", "logs");
 
 class ThreadLoggerImpl {
   platformId;
@@ -57098,16 +57407,16 @@ class ThreadLoggerImpl {
     this.enabled = options?.enabled ?? true;
     this.bufferSize = options?.bufferSize ?? 10;
     this.flushIntervalMs = options?.flushIntervalMs ?? 1000;
-    this.logPath = join8(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
+    this.logPath = join10(LOGS_BASE_DIR, platformId, `${claudeSessionId}.jsonl`);
     if (this.enabled) {
       const dir = dirname7(this.logPath);
-      if (!existsSync9(dir)) {
-        mkdirSync5(dir, { recursive: true });
+      if (!existsSync10(dir)) {
+        mkdirSync6(dir, { recursive: true });
       }
       this.flushTimer = setInterval(() => {
         this.flushSync();
       }, this.flushIntervalMs);
-      log13.debug(`Thread logger initialized: ${this.logPath}`);
+      log14.debug(`Thread logger initialized: ${this.logPath}`);
     }
   }
   isEnabled() {
@@ -57221,7 +57530,7 @@ class ThreadLoggerImpl {
       this.flushTimer = null;
     }
     this.flushSync();
-    log13.debug(`Thread logger closed: ${this.logPath}`);
+    log14.debug(`Thread logger closed: ${this.logPath}`);
   }
   addEntry(entry) {
     this.buffer.push(entry);
@@ -57236,14 +57545,14 @@ class ThreadLoggerImpl {
       const lines = this.buffer.map((entry) => JSON.stringify(entry)).join(`
 `) + `
 `;
-      const isNewFile = !existsSync9(this.logPath);
+      const isNewFile = !existsSync10(this.logPath);
       appendFileSync(this.logPath, lines, { encoding: "utf8", mode: 384 });
       if (isNewFile) {
-        chmodSync5(this.logPath, 384);
+        chmodSync6(this.logPath, 384);
       }
       this.buffer = [];
     } catch (err) {
-      log13.error(`Failed to flush thread log: ${err}`);
+      log14.error(`Failed to flush thread log: ${err}`);
     }
   }
 }
@@ -57274,13 +57583,13 @@ function createThreadLogger(platformId, threadId, claudeSessionId, options) {
 function cleanupOldLogs(retentionDays = 30) {
   const cutoffMs = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
   let deletedCount = 0;
-  if (!existsSync9(LOGS_BASE_DIR)) {
+  if (!existsSync10(LOGS_BASE_DIR)) {
     return 0;
   }
   try {
     const platformDirs = readdirSync2(LOGS_BASE_DIR);
     for (const platformId of platformDirs) {
-      const platformDir = join8(LOGS_BASE_DIR, platformId);
+      const platformDir = join10(LOGS_BASE_DIR, platformId);
       const stat = statSync2(platformDir);
       if (!stat.isDirectory())
         continue;
@@ -57288,49 +57597,49 @@ function cleanupOldLogs(retentionDays = 30) {
       for (const file of logFiles) {
         if (!file.endsWith(".jsonl"))
           continue;
-        const filePath = join8(platformDir, file);
+        const filePath = join10(platformDir, file);
         try {
           const fileStat = statSync2(filePath);
           if (fileStat.mtimeMs < cutoffMs) {
             unlinkSync2(filePath);
             deletedCount++;
-            log13.debug(`Deleted old log file: ${filePath}`);
+            log14.debug(`Deleted old log file: ${filePath}`);
           }
         } catch (err) {
-          log13.warn(`Failed to check/delete log file ${filePath}: ${err}`);
+          log14.warn(`Failed to check/delete log file ${filePath}: ${err}`);
         }
       }
       try {
         const remaining = readdirSync2(platformDir);
         if (remaining.length === 0) {
           rmdirSync(platformDir);
-          log13.debug(`Removed empty platform log directory: ${platformDir}`);
+          log14.debug(`Removed empty platform log directory: ${platformDir}`);
         }
       } catch {}
     }
     if (deletedCount > 0) {
-      log13.info(`Cleaned up ${deletedCount} old log file(s)`);
+      log14.info(`Cleaned up ${deletedCount} old log file(s)`);
     }
   } catch (err) {
-    log13.error(`Failed to clean up old logs: ${err}`);
+    log14.error(`Failed to clean up old logs: ${err}`);
   }
   return deletedCount;
 }
 function getLogFilePath(platformId, sessionId) {
-  return join8(LOGS_BASE_DIR, platformId, `${sessionId}.jsonl`);
+  return join10(LOGS_BASE_DIR, platformId, `${sessionId}.jsonl`);
 }
 function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
   const logPath = getLogFilePath(platformId, sessionId);
-  log13.debug(`Reading log entries from: ${logPath}`);
-  if (!existsSync9(logPath)) {
-    log13.debug(`Log file does not exist: ${logPath}`);
+  log14.debug(`Reading log entries from: ${logPath}`);
+  if (!existsSync10(logPath)) {
+    log14.debug(`Log file does not exist: ${logPath}`);
     return [];
   }
   try {
-    const content = readFileSync8(logPath, "utf8");
+    const content = readFileSync9(logPath, "utf8");
     const lines = content.trim().split(`
 `);
-    log13.debug(`Log file has ${lines.length} lines`);
+    log14.debug(`Log file has ${lines.length} lines`);
     const recentLines = lines.slice(-maxLines);
     const entries = [];
     for (const line of recentLines) {
@@ -57340,412 +57649,14 @@ function readRecentLogEntries(platformId, sessionId, maxLines = 50) {
         entries.push(JSON.parse(line));
       } catch {}
     }
-    log13.debug(`Parsed ${entries.length} log entries`);
+    log14.debug(`Parsed ${entries.length} log entries`);
     return entries;
   } catch (err) {
-    log13.error(`Failed to read log file: ${err}`);
+    log14.error(`Failed to read log file: ${err}`);
     return [];
   }
 }
 
-// src/cleanup/scheduler.ts
-init_worktree();
-var log14 = createLogger("cleanup");
-var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
-var MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
-
-class CleanupScheduler {
-  intervalMs;
-  logRetentionDays;
-  threadLogsEnabled;
-  sessionStore;
-  maxWorktreeAgeMs;
-  cleanupWorktrees;
-  timer = null;
-  isRunning = false;
-  constructor(options) {
-    this.intervalMs = options.intervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS;
-    this.logRetentionDays = options.logRetentionDays ?? 30;
-    this.threadLogsEnabled = options.threadLogsEnabled ?? true;
-    this.sessionStore = options.sessionStore;
-    this.maxWorktreeAgeMs = options.maxWorktreeAgeMs ?? MAX_WORKTREE_AGE_MS;
-    this.cleanupWorktrees = options.cleanupWorktrees ?? true;
-  }
-  start() {
-    if (this.isRunning) {
-      log14.debug("Cleanup scheduler already running");
-      return;
-    }
-    this.isRunning = true;
-    log14.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
-    this.runCleanup().catch((err) => {
-      log14.warn(`Initial cleanup failed: ${err}`);
-    });
-    this.timer = setInterval(() => {
-      this.runCleanup().catch((err) => {
-        log14.warn(`Periodic cleanup failed: ${err}`);
-      });
-    }, this.intervalMs);
-  }
-  stop() {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    this.isRunning = false;
-    log14.debug("Cleanup scheduler stopped");
-  }
-  async runCleanup() {
-    const startTime = Date.now();
-    log14.debug("Running background cleanup...");
-    const stats = {
-      logsDeleted: 0,
-      worktreesCleaned: 0,
-      metadataCleaned: 0,
-      errors: []
-    };
-    const cleanupTasks = [
-      this.cleanupLogs().catch((err) => {
-        stats.errors.push(`Log cleanup: ${err}`);
-        return 0;
-      })
-    ];
-    if (this.cleanupWorktrees) {
-      cleanupTasks.push(this.cleanupOrphanedWorktrees().catch((err) => {
-        stats.errors.push(`Worktree cleanup: ${err}`);
-        return { cleaned: 0, metadata: 0 };
-      }));
-    }
-    const [logStats, worktreeStats = { cleaned: 0, metadata: 0 }] = await Promise.all(cleanupTasks);
-    stats.logsDeleted = logStats;
-    stats.worktreesCleaned = worktreeStats.cleaned;
-    stats.metadataCleaned = worktreeStats.metadata;
-    const elapsed = Date.now() - startTime;
-    const totalCleaned = stats.logsDeleted + stats.worktreesCleaned + stats.metadataCleaned;
-    if (totalCleaned > 0 || stats.errors.length > 0) {
-      log14.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
-    } else {
-      log14.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
-    }
-    return stats;
-  }
-  async cleanupLogs() {
-    if (!this.threadLogsEnabled) {
-      return 0;
-    }
-    return new Promise((resolve5) => {
-      try {
-        const deleted = cleanupOldLogs(this.logRetentionDays);
-        resolve5(deleted);
-      } catch (err) {
-        log14.warn(`Log cleanup error: ${err}`);
-        resolve5(0);
-      }
-    });
-  }
-  async cleanupOrphanedWorktrees() {
-    const worktreesDir = getWorktreesDir();
-    const result = { cleaned: 0, metadata: 0 };
-    if (!existsSync10(worktreesDir)) {
-      log14.debug("No worktrees directory exists, nothing to clean");
-      return result;
-    }
-    const persisted = this.sessionStore.load();
-    const activeWorktrees = new Set;
-    for (const session of persisted.values()) {
-      if (session.worktreeInfo?.worktreePath) {
-        activeWorktrees.add(session.worktreeInfo.worktreePath);
-      }
-    }
-    const now = Date.now();
-    try {
-      const entries = await readdir(worktreesDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory())
-          continue;
-        const worktreePath = join9(worktreesDir, entry.name);
-        if (activeWorktrees.has(worktreePath)) {
-          log14.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
-          continue;
-        }
-        const meta = await readWorktreeMetadata(worktreePath);
-        let shouldCleanup = false;
-        let cleanupReason = "";
-        if (meta) {
-          const lastActivity = new Date(meta.lastActivityAt).getTime();
-          const age = now - lastActivity;
-          if (meta.sessionId && age < this.maxWorktreeAgeMs) {
-            log14.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
-            continue;
-          }
-          const merged = age >= this.maxWorktreeAgeMs ? await isBranchMerged(meta.repoRoot, meta.branch).catch(() => false) : false;
-          if (merged) {
-            shouldCleanup = true;
-            cleanupReason = `branch "${meta.branch}" was merged`;
-          } else if (age >= this.maxWorktreeAgeMs) {
-            shouldCleanup = true;
-            cleanupReason = `inactive for ${Math.round(age / 3600000)}h`;
-          } else {
-            log14.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
-            continue;
-          }
-        } else {
-          shouldCleanup = true;
-          cleanupReason = "no metadata";
-        }
-        if (!shouldCleanup)
-          continue;
-        log14.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
-        try {
-          if (meta?.repoRoot) {
-            await removeWorktree(meta.repoRoot, worktreePath);
-          } else {
-            await rm(worktreePath, { recursive: true, force: true });
-          }
-          result.cleaned++;
-          await removeWorktreeMetadata(worktreePath);
-          result.metadata++;
-        } catch (err) {
-          log14.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
-          try {
-            await rm(worktreePath, { recursive: true, force: true });
-            result.cleaned++;
-            await removeWorktreeMetadata(worktreePath);
-            result.metadata++;
-          } catch (rmErr) {
-            log14.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
-          }
-        }
-      }
-    } catch (err) {
-      log14.warn(`Failed to scan worktrees directory: ${err}`);
-    }
-    return result;
-  }
-}
-// src/operations/monitor/handler.ts
-init_logger();
-
-// src/session/lifecycle-fsm.ts
-init_logger();
-var log15 = createLogger("fsm");
-var ALLOWED_TRANSITIONS = {
-  starting: new Set(["active", "paused", "interrupted", "cancelling", "restarting"]),
-  active: new Set([
-    "active",
-    "processing",
-    "paused",
-    "interrupted",
-    "restarting",
-    "cancelling",
-    "ending"
-  ]),
-  processing: new Set([
-    "active",
-    "paused",
-    "interrupted",
-    "restarting",
-    "cancelling"
-  ]),
-  paused: new Set(["active", "cancelling", "restarting"]),
-  interrupted: new Set(["active", "cancelling", "restarting", "paused"]),
-  restarting: new Set(["active", "paused", "cancelling"]),
-  cancelling: new Set(["ending"]),
-  ending: new Set
-};
-function checkTransition(from, to, sessionId) {
-  const allowed = ALLOWED_TRANSITIONS[from];
-  if (allowed.has(to))
-    return;
-  const msg = `illegal lifecycle transition ${from} -> ${to}`;
-  const payload = {
-    event: "fsm.illegal_transition",
-    from,
-    to,
-    sessionId
-  };
-  if (process.env.CLAUDE_THREADS_FSM_STRICT === "1") {
-    throw new Error(`${msg} (sessionId=${sessionId})`);
-  }
-  log15.warn(msg, payload);
-}
-
-// src/session/timer-manager.ts
-function createSessionTimers() {
-  return {
-    updateTimer: null,
-    typingTimer: null,
-    statusBarTimer: null
-  };
-}
-function clearAllTimers(timers) {
-  if (timers.updateTimer) {
-    clearTimeout(timers.updateTimer);
-    timers.updateTimer = null;
-  }
-  if (timers.typingTimer) {
-    clearInterval(timers.typingTimer);
-    timers.typingTimer = null;
-  }
-  if (timers.statusBarTimer) {
-    clearInterval(timers.statusBarTimer);
-    timers.statusBarTimer = null;
-  }
-}
-
-// src/session/types.ts
-function createSessionLifecycle() {
-  return {
-    state: "starting",
-    resumeFailCount: 0,
-    hasClaudeResponded: false
-  };
-}
-function createResumedLifecycle(resumeFailCount = 0) {
-  return {
-    state: "active",
-    resumeFailCount,
-    hasClaudeResponded: true
-  };
-}
-function isSessionRestarting(session) {
-  return session.lifecycle.state === "restarting";
-}
-function isSessionCancelled(session) {
-  return session.lifecycle.state === "cancelling";
-}
-function transitionTo(session, newState) {
-  checkTransition(session.lifecycle.state, newState, session.sessionId);
-  session.lifecycle.state = newState;
-}
-function markClaudeResponded(session) {
-  session.lifecycle.hasClaudeResponded = true;
-  if (session.lifecycle.state === "starting") {
-    session.lifecycle.state = "active";
-  }
-}
-function getSessionStatus(session) {
-  if (session.isProcessing) {
-    return session.lifecycle.hasClaudeResponded ? "active" : "starting";
-  }
-  return "idle";
-}
-
-// src/session/authorization.ts
-function isAuthorizedForSession(check) {
-  const { username, platform, sessionAllowedUsers } = check;
-  if (!username || username === "unknown") {
-    return false;
-  }
-  if (platform.isUserAllowed(username)) {
-    return true;
-  }
-  return sessionAllowedUsers?.has(username) ?? false;
-}
-
-// src/mcp/decision-bridge.ts
-import { createServer, createConnection } from "node:net";
-import { tmpdir as tmpdir2 } from "node:os";
-import { join as join10 } from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
-import { mkdtempSync } from "node:fs";
-import { rm as rm2 } from "node:fs/promises";
-
-class BridgeUnavailableError extends Error {
-}
-function bridgeSocketPath() {
-  if (process.platform === "win32") {
-    return `\\\\.\\pipe\\ctb-${randomUUID2()}`;
-  }
-  const dir = mkdtempSync(join10(tmpdir2(), "ctb-"));
-  return join10(dir, "b.sock");
-}
-
-class DecisionBridgeServer {
-  server;
-  path;
-  liveSockets = new Set;
-  constructor(server, path2) {
-    this.server = server;
-    this.path = path2;
-  }
-  static async create(handler) {
-    const path2 = bridgeSocketPath();
-    const liveSockets = new Set;
-    const server = createServer((socket) => {
-      liveSockets.add(socket);
-      socket.once("close", () => liveSockets.delete(socket));
-      let buffer = "";
-      const aborter = new AbortController;
-      let responded = false;
-      socket.on("data", (chunk) => {
-        buffer += chunk.toString("utf8");
-        const newline = buffer.indexOf(`
-`);
-        if (newline === -1)
-          return;
-        const line = buffer.slice(0, newline);
-        buffer = "";
-        let request;
-        try {
-          request = JSON.parse(line);
-        } catch {
-          responded = true;
-          socket.end(JSON.stringify({ behavior: "deny", message: "Malformed bridge request" }) + `
-`);
-          return;
-        }
-        handler(request, aborter.signal).then((response) => {
-          responded = true;
-          socket.end(JSON.stringify(response) + `
-`);
-        }).catch((err) => {
-          responded = true;
-          if (err instanceof BridgeUnavailableError) {
-            socket.destroy();
-            return;
-          }
-          socket.end(JSON.stringify({
-            behavior: "deny",
-            message: `Bridge handler failed: ${err instanceof Error ? err.message : String(err)}`
-          }) + `
-`);
-        });
-      });
-      socket.on("close", () => {
-        if (!responded)
-          aborter.abort();
-      });
-      socket.on("error", () => {});
-    });
-    try {
-      await new Promise((resolve5, reject) => {
-        server.once("error", reject);
-        server.listen(path2, () => {
-          server.removeListener("error", reject);
-          resolve5();
-        });
-      });
-    } catch (err) {
-      if (process.platform !== "win32") {
-        await rm2(join10(path2, ".."), { recursive: true, force: true }).catch(() => {});
-      }
-      throw err;
-    }
-    const bridge = new DecisionBridgeServer(server, path2);
-    bridge.liveSockets = liveSockets;
-    return bridge;
-  }
-  async close() {
-    for (const socket of this.liveSockets)
-      socket.destroy();
-    await new Promise((resolve5) => this.server.close(() => resolve5()));
-    if (process.platform !== "win32") {
-      await rm2(join10(this.path, ".."), { recursive: true, force: true }).catch(() => {});
-    }
-  }
-}
-
 // src/commands/registry.ts
 var COMMAND_REGISTRY = [
   {
@@ -57874,6 +57785,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",
@@ -57998,6 +57931,8 @@ var COMMAND_PATTERNS = [
   ["mentions", /^!mentions(?:\s+(on|off))?\s*$/i],
   ["remember", /^!remember\s+([\s\S]+)$/i],
   ["memory", /^!memory(?:\s+([\s\S]+))?$/i],
+  ["routines", /^!routines(?:\s+([\s\S]+))?$/i],
+  ["routine", /^!routine\s+([\s\S]+)$/i],
   ["update", /^!update(?:\s+(now|defer))?\s*$/i],
   ["context", /^!context\s*$/i],
   ["cost", /^!cost\s*$/i],
@@ -58134,7 +58069,7 @@ ${formatter.formatBold("Reactions:")}
 }
 
 // src/changelog.ts
-import { readFileSync as readFileSync9, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync10, existsSync as existsSync11 } from "fs";
 import { dirname as dirname8, resolve as resolve5 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __dirname4 = dirname8(fileURLToPath4(import.meta.url));
@@ -58154,7 +58089,7 @@ function getReleaseNotes(version) {
     return null;
   }
   try {
-    const content = readFileSync9(changelogPath, "utf-8");
+    const content = readFileSync10(changelogPath, "utf-8");
     return parseChangelog(content, version);
   } catch {
     return null;
@@ -58376,6 +58311,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 };
@@ -58567,6 +58526,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);
@@ -58610,7 +58571,7 @@ async function handleDynamicSlashCommand(command, args, ctx) {
 }
 // src/commands/system-prompt-generator.ts
 init_logger();
-var log16 = createLogger("system-prompt");
+var log15 = createLogger("system-prompt");
 function formatUserCommand(cmd) {
   const cmdStr = cmd.args ? `\`!${cmd.command} ${cmd.args}\`` : `\`!${cmd.command}\``;
   const description = cmd.description;
@@ -58649,7 +58610,7 @@ async function resolveCollaborators(platform, platformId, ownerUsername, allowed
       continue;
     const email = githubEmailsStore.get(platformId, username);
     if (!email) {
-      log16.debug(`Collaborator @${username} has no registered GitHub noreply email — skipping`);
+      log15.debug(`Collaborator @${username} has no registered GitHub noreply email — skipping`);
       continue;
     }
     let name = username;
@@ -58658,7 +58619,7 @@ async function resolveCollaborators(platform, platformId, ownerUsername, allowed
       if (user)
         name = user.displayName || user.username;
     } catch (err) {
-      log16.debug(`Display name lookup failed for @${username}: ${err.message}`);
+      log15.debug(`Display name lookup failed for @${username}: ${err.message}`);
     }
     resolved.push({ username, name, email });
   }
@@ -58781,14 +58742,55 @@ ${avoidCommands.map((c) => `- \`!${c.command}\` - ${c.reason}`).join(`
 `.trim();
 }
 // src/session/lifecycle.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 import { existsSync as existsSync13 } from "fs";
 
 // src/utils/keep-alive.ts
 init_logger();
 import { spawn as spawn2 } from "child_process";
-var log17 = createLogger("keepalive");
-
+var log16 = 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;
@@ -58802,7 +58804,7 @@ class KeepAliveManager {
     if (!enabled && this.keepAliveProcess) {
       this.stopKeepAlive();
     }
-    log17.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
+    log16.debug(`Keep-alive ${enabled ? "enabled" : "disabled"}`);
   }
   isEnabled() {
     return this.enabled;
@@ -58812,7 +58814,7 @@ class KeepAliveManager {
   }
   sessionStarted() {
     this.activeSessionCount++;
-    log17.debug(`Session started (${this.activeSessionCount} active)`);
+    log16.debug(`Session started (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 1) {
       this.startKeepAlive();
     }
@@ -58821,7 +58823,7 @@ class KeepAliveManager {
     if (this.activeSessionCount > 0) {
       this.activeSessionCount--;
     }
-    log17.debug(`Session ended (${this.activeSessionCount} active)`);
+    log16.debug(`Session ended (${this.activeSessionCount} active)`);
     if (this.activeSessionCount === 0) {
       this.stopKeepAlive();
     }
@@ -58835,11 +58837,11 @@ class KeepAliveManager {
   }
   startKeepAlive() {
     if (!this.enabled) {
-      log17.debug("Keep-alive disabled, skipping");
+      log16.debug("Keep-alive disabled, skipping");
       return;
     }
     if (this.keepAliveProcess) {
-      log17.debug("Keep-alive already running");
+      log16.debug("Keep-alive already running");
       return;
     }
     switch (this.platform) {
@@ -58853,121 +58855,105 @@ class KeepAliveManager {
         this.startWindowsKeepAlive();
         break;
       default:
-        log17.warn(`Keep-alive not supported on ${this.platform}`);
+        log16.warn(`Keep-alive not supported on ${this.platform}`);
     }
   }
   stopKeepAlive() {
     if (this.keepAliveProcess) {
-      log17.debug("Stopping keep-alive");
+      log16.debug("Stopping keep-alive");
       this.keepAliveProcess.kill();
       this.keepAliveProcess = null;
     }
   }
   startMacOSKeepAlive() {
     try {
-      this.keepAliveProcess = spawn2("caffeinate", ["-s", "-i"], {
-        stdio: "ignore",
+      const spec = keepAliveSpawnSpec("darwin", process.pid);
+      if (!spec)
+        return;
+      this.keepAliveProcess = spawn2(spec.command, spec.args, {
+        stdio: spec.stdio,
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log17.error(`Failed to start caffeinate: ${err.message}`);
+        log16.error(`Failed to start caffeinate: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log17.debug(`caffeinate exited with code ${code}`);
+          log16.debug(`caffeinate exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log17.info("Sleep prevention active (caffeinate)");
+      log16.info("Sleep prevention active (caffeinate)");
     } catch (err) {
-      log17.error(`Failed to start caffeinate: ${err}`);
+      log16.error(`Failed to start caffeinate: ${err}`);
     }
   }
   startLinuxKeepAlive() {
     try {
-      this.keepAliveProcess = spawn2("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 = spawn2(spec.command, spec.args, {
+        stdio: spec.stdio,
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log17.debug(`systemd-inhibit not available: ${err.message}`);
+        log16.debug(`systemd-inhibit not available: ${err.message}`);
         this.keepAliveProcess = null;
         this.startLinuxKeepAliveFallback();
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log17.debug(`systemd-inhibit exited with code ${code}`);
+          log16.debug(`systemd-inhibit exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log17.info("Sleep prevention active (systemd-inhibit)");
+      log16.info("Sleep prevention active (systemd-inhibit)");
     } catch (err) {
-      log17.debug(`Failed to start systemd-inhibit: ${err}`);
+      log16.debug(`Failed to start systemd-inhibit: ${err}`);
       this.startLinuxKeepAliveFallback();
     }
   }
   startLinuxKeepAliveFallback() {
     try {
-      this.keepAliveProcess = spawn2("bash", [
-        "-c",
-        `while true; do xdg-screensaver reset 2>/dev/null || true; sleep 60; done`
-      ], {
+      this.keepAliveProcess = spawn2("bash", ["-c", linuxFallbackScript(process.pid)], {
         stdio: "ignore",
         detached: false
       });
       this.keepAliveProcess.on("error", (err) => {
-        log17.warn(`Linux keep-alive fallback not available: ${err.message}`);
+        log16.warn(`Linux keep-alive fallback not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", () => {
         this.keepAliveProcess = null;
       });
-      log17.info("Sleep prevention active (xdg-screensaver)");
+      log16.info("Sleep prevention active (xdg-screensaver)");
     } catch (err) {
-      log17.warn(`Linux keep-alive not available: ${err}`);
+      log16.warn(`Linux keep-alive not available: ${err}`);
     }
   }
   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 = spawn2("powershell", ["-NoProfile", "-Command", script], {
         stdio: "ignore",
         detached: false,
         windowsHide: true
       });
       this.keepAliveProcess.on("error", (err) => {
-        log17.warn(`Windows keep-alive not available: ${err.message}`);
+        log16.warn(`Windows keep-alive not available: ${err.message}`);
         this.keepAliveProcess = null;
       });
       this.keepAliveProcess.on("exit", (code) => {
         if (code !== null && code !== 0 && this.activeSessionCount > 0) {
-          log17.debug(`PowerShell keep-alive exited with code ${code}`);
+          log16.debug(`PowerShell keep-alive exited with code ${code}`);
         }
         this.keepAliveProcess = null;
       });
-      log17.info("Sleep prevention active (SetThreadExecutionState)");
+      log16.info("Sleep prevention active (SetThreadExecutionState)");
     } catch (err) {
-      log17.warn(`Windows keep-alive not available: ${err}`);
+      log16.warn(`Windows keep-alive not available: ${err}`);
     }
   }
 }
@@ -58975,7 +58961,7 @@ var keepAlive = new KeepAliveManager;
 
 // src/utils/error-handler/index.ts
 init_logger();
-var log18 = createLogger("error");
+var log17 = createLogger("error");
 
 class SessionError extends Error {
   sessionId;
@@ -59001,19 +58987,19 @@ async function handleError(error, context, severity = "recoverable") {
   const sessionPart = sessionId ? ` (${formatShortId(sessionId)})` : "";
   const logMessage = `${context.action}${sessionPart}: ${message}`;
   if (severity === "recoverable") {
-    log18.warn(logMessage);
+    log17.warn(logMessage);
   } else {
-    log18.error(logMessage, error instanceof Error ? error : undefined);
+    log17.error(logMessage, error instanceof Error ? error : undefined);
   }
   if (context.details) {
-    log18.debugJson("Error details", context.details);
+    log17.debugJson("Error details", context.details);
   }
   if (context.notifyUser && context.session) {
     try {
       const fmt = context.session.platform.getFormatter();
       await context.session.platform.createPost(`⚠️ ${fmt.formatBold("Error")}: ${context.action} failed - ${message}`, context.session.threadId);
     } catch (notifyError) {
-      log18.warn(`Could not notify user: ${notifyError}`);
+      log17.warn(`Could not notify user: ${notifyError}`);
     }
   }
   if (severity === "session-fatal" || severity === "system-fatal") {
@@ -59040,7 +59026,7 @@ async function logAndNotify(error, context) {
 }
 function logSilentError(context, error) {
   const message = error instanceof Error ? error.message : String(error);
-  log18.debug(`[${context}] Silently caught: ${message}`);
+  log17.debug(`[${context}] Silently caught: ${message}`);
 }
 
 // src/session/lifecycle.ts
@@ -59060,8 +59046,8 @@ function createSessionLog(baseLog) {
 init_logger();
 init_emoji();
 init_worktree();
-var log19 = createLogger("helpers");
-var sessionLog = createSessionLog(log19);
+var log18 = createLogger("helpers");
+var sessionLog = createSessionLog(log18);
 var POST_TYPES = {
   info: "",
   success: "✅",
@@ -59147,10 +59133,10 @@ function updateLastMessage(session, post2) {
 
 // src/operations/streaming/handler.ts
 init_logger();
-import { lstat, mkdir as mkdir2, mkdtemp, rm as rm3, writeFile as writeFile2 } from "fs/promises";
+import { lstat, mkdir as mkdir2, mkdtemp, rm as rm2, writeFile as writeFile2 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { join as join11 } from "path";
-var log20 = createLogger("streaming");
+var log19 = createLogger("streaming");
 var UPLOAD_ROOT_DIR = "claude-threads-uploads";
 function safeIdSegment2(id) {
   return id.replace(/[^A-Za-z0-9._-]/g, "_");
@@ -59163,9 +59149,9 @@ async function cleanupSessionUploads(platformId, threadId) {
     return;
   const dir = getSessionUploadDir(platformId, threadId);
   try {
-    await rm3(dir, { recursive: true, force: true });
+    await rm2(dir, { recursive: true, force: true });
   } catch (err) {
-    log20.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
+    log19.debug(`Upload cleanup for ${platformId}:${threadId} failed (ignored): ${err}`);
   }
 }
 function sanitizeForPrompt(value) {
@@ -59186,7 +59172,7 @@ async function saveFilesToUploadDir(platform, uploadDir, files, debug = false) {
     for (const file of files) {
       skipped.push({ name: file.name, reason: "Refusing to write under symlinked upload directory" });
     }
-    log20.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
+    log19.error(`Upload dir is a symlink, refusing all writes: ${uploadDir}`);
     return { saved, skipped };
   }
   const messageDir = await mkdtemp(join11(uploadDir, `${Date.now().toString(36)}-`));
@@ -59204,11 +59190,11 @@ async function saveFilesToUploadDir(platform, uploadDir, files, debug = false) {
         size: buffer.length
       });
       if (debug) {
-        log20.debug(`Saved ${file.name} → ${absolutePath} (${formatBytes(buffer.length)})`);
+        log19.debug(`Saved ${file.name} → ${absolutePath} (${formatBytes(buffer.length)})`);
       }
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
-      log20.error(`Failed to save uploaded file ${file.name}: ${message}`);
+      log19.error(`Failed to save uploaded file ${file.name}: ${message}`);
       skipped.push({
         name: file.name,
         reason: `Download failed: ${message}`
@@ -59284,7 +59270,7 @@ function buildRestartCliOptions(session, ctx) {
 }
 
 // src/operations/commands/handler.ts
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 import { resolve as resolve6 } from "path";
 import { existsSync as existsSync12, statSync as statSync3 } from "fs";
 
@@ -59631,9 +59617,9 @@ node_default(Temp.purgeSyncAll);
 var temp_default = Temp;
 
 // node_modules/atomically/dist/index.js
-function writeFileSync6(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
+function writeFileSync7(filePath, data, options = DEFAULT_WRITE_OPTIONS) {
   if (isString(options))
-    return writeFileSync6(filePath, data, { encoding: options });
+    return writeFileSync7(filePath, data, { encoding: options });
   const timeout = options.timeout ?? DEFAULT_TIMEOUT_SYNC;
   const retryOptions = { timeout };
   let tempDisposer = null;
@@ -59961,7 +59947,7 @@ class Configstore {
       }
       if (error.name === "SyntaxError") {
         if (this._clearInvalidConfig) {
-          writeFileSync6(this._path, "", writeFileOptions);
+          writeFileSync7(this._path, "", writeFileOptions);
           return {};
         }
         throw error;
@@ -59973,7 +59959,7 @@ class Configstore {
   set all(value) {
     try {
       import_graceful_fs.default.mkdirSync(path5.dirname(this._path), mkdirOptions);
-      writeFileSync6(this._path, JSON.stringify(value, undefined, "\t"), writeFileOptions);
+      writeFileSync7(this._path, JSON.stringify(value, undefined, "\t"), writeFileOptions);
     } catch (error) {
       handlePermissionError(error);
     }
@@ -62701,7 +62687,7 @@ init_emoji();
 
 // src/operations/bug-report/handler.ts
 import { execSync as execSync2 } from "child_process";
-import { writeFileSync as writeFileSync7, unlinkSync as unlinkSync3 } from "fs";
+import { writeFileSync as writeFileSync8, unlinkSync as unlinkSync3 } from "fs";
 import { tmpdir as tmpdir4 } from "os";
 import { join as join12 } from "path";
 
@@ -63285,7 +63271,7 @@ async function createGitHubIssue(title, body, workingDir) {
   }
   const bodyFile = join12(tmpdir4(), `bug-body-${Date.now()}.md`);
   try {
-    writeFileSync7(bodyFile, body, "utf-8");
+    writeFileSync8(bodyFile, body, "utf-8");
     const cmd = `gh issue create --repo "${GITHUB_REPO}" --title "${escapeShell(title)}" --body-file "${bodyFile}"`;
     const result = execSync2(cmd, {
       cwd: workingDir,
@@ -66942,7 +66928,8 @@ class PromptExecutor extends BaseExecutor {
     return {
       pendingContextPrompt: null,
       pendingExistingWorktreePrompt: null,
-      pendingUpdatePrompt: null
+      pendingUpdatePrompt: null,
+      pendingRoutinePrompt: null
     };
   }
   getInitialState() {
@@ -66952,14 +66939,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) {
@@ -67089,6 +67078,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, emoji, user, action, ctx) {
     ctx.logger.debug(`PromptExecutor.handleReaction: postId=${postId.substring(0, 8)}, emoji=${emoji}, user=${user}, action=${action}`);
     if (action !== "added") {
@@ -67149,6 +67162,18 @@ class PromptExecutor extends BaseExecutor {
       ctx.logger.debug(`PromptExecutor: emoji ${emoji} not valid for update prompt, ignoring`);
       return false;
     }
+    if (this.state.pendingRoutinePrompt?.postId === postId) {
+      if (isApprovalEmoji(emoji)) {
+        ctx.logger.debug(`Routine prompt reaction from @${user}: approve`);
+        return this.handleRoutinePromptResponse(postId, true, user, ctx);
+      }
+      if (isDenialEmoji(emoji)) {
+        ctx.logger.debug(`Routine prompt reaction from @${user}: discard`);
+        return this.handleRoutinePromptResponse(postId, false, user, ctx);
+      }
+      ctx.logger.debug(`PromptExecutor: emoji ${emoji} not valid for routine prompt, ignoring`);
+      return false;
+    }
     ctx.logger.debug(`PromptExecutor: no pending prompt state matches postId=${postId.substring(0, 8)}`);
     return false;
   }
@@ -67243,7 +67268,7 @@ class BugReportExecutor extends BaseExecutor {
 // src/operations/executors/worktree-prompt.ts
 init_emoji();
 init_logger();
-var log21 = createLogger("wt-prompt");
+var log20 = createLogger("wt-prompt");
 // src/operations/message-manager.ts
 init_logger();
 
@@ -67323,7 +67348,7 @@ function formatRelativeTime(date) {
   return `${diffMin} min ago`;
 }
 // src/operations/message-manager.ts
-var log22 = createLogger("msg-mgr");
+var log21 = createLogger("msg-mgr");
 
 class MessageManager {
   platform;
@@ -67416,7 +67441,7 @@ class MessageManager {
     });
   }
   async handleEvent(event) {
-    const logger = log22.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     const transformCtx = {
       sessionId: this.sessionId,
       formatter: this.platform.getFormatter(),
@@ -67470,7 +67495,7 @@ class MessageManager {
     }
   }
   async executeOperation(op) {
-    const logger = log22.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     const ctx = this.getExecutorContext();
     try {
       if (isContentOp(op)) {
@@ -67538,7 +67563,7 @@ class MessageManager {
       threadId: this.threadId,
       platform: this.platform,
       formatter: this.platform.getFormatter(),
-      logger: log22.forSession(this.sessionId),
+      logger: log21.forSession(this.sessionId),
       postTracker: this.postTracker,
       contentBreaker: this.contentBreaker,
       threadLogger: this.session.threadLogger,
@@ -67657,6 +67682,9 @@ class MessageManager {
   clearPendingUpdatePrompt() {
     this.promptExecutor.clearPendingUpdatePrompt();
   }
+  setPendingRoutinePrompt(prompt) {
+    this.promptExecutor.setPendingRoutinePrompt(prompt);
+  }
   setPendingBugReport(report) {
     this.bugReportExecutor.setPendingBugReport(report);
   }
@@ -67755,13 +67783,13 @@ class MessageManager {
     return this.systemExecutor.postSuccess(message, this.getExecutorContext());
   }
   async prepareForUserMessage() {
-    const logger = log22.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     logger.debug("Preparing for new user message");
     await this.closeCurrentPost();
     await this.bumpTaskList();
   }
   async handleUserMessage(message, files, username, displayName) {
-    const logger = log22.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     if (!this.session.claude.isRunning()) {
       logger.debug("Claude not running, ignoring user message");
       return false;
@@ -67804,7 +67832,7 @@ class MessageManager {
     ];
   }
   async handleReaction(postId, emoji, user, action) {
-    const logger = log22.forSession(this.sessionId);
+    const logger = log21.forSession(this.sessionId);
     const ctx = this.getExecutorContext();
     logger.debug(`Routing reaction: postId=${postId}, emoji=${emoji}, user=${user}, action=${action}`);
     for (const { name, executor } of this.reactionDispatchList()) {
@@ -67902,7 +67930,7 @@ class MessageManager {
 }
 // src/operations/sticky-message/handler.ts
 init_logger();
-var log23 = createLogger("sticky");
+var log22 = createLogger("sticky");
 var botStartedAt = new Date;
 function getPendingPrompts(session) {
   const prompts2 = [];
@@ -67977,21 +68005,21 @@ function initialize(store) {
     stickyPostIds.set(platformId, postId);
   }
   if (persistedIds.size > 0) {
-    log23.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
+    log22.info(`\uD83D\uDCCC Restored ${persistedIds.size} sticky post ID(s) from persistence`);
   }
 }
 function setPlatformPaused(platformId, paused) {
   if (paused) {
     pausedPlatforms.set(platformId, true);
-    log23.debug(`Platform ${platformId} marked as paused`);
+    log22.debug(`Platform ${platformId} marked as paused`);
   } else {
     pausedPlatforms.delete(platformId);
-    log23.debug(`Platform ${platformId} marked as active`);
+    log22.debug(`Platform ${platformId} marked as active`);
   }
 }
 function setShuttingDown(shuttingDown) {
   isShuttingDown = shuttingDown;
-  log23.debug(`Bot shutdown state: ${shuttingDown}`);
+  log22.debug(`Bot shutdown state: ${shuttingDown}`);
 }
 function getTaskContent(session) {
   const taskState = session.messageManager?.getTaskListState();
@@ -68324,12 +68352,12 @@ async function validateLastMessageIds(platform, sessions) {
     try {
       const post2 = await platform.getPost(lastMessageId);
       if (!post2) {
-        log23.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
+        log22.debug(`lastMessageId ${lastMessageId.substring(0, 8)} for session ${session.sessionId} was deleted, clearing`);
         session.lastMessageId = undefined;
         session.lastMessageTs = undefined;
       }
     } catch (err) {
-      log23.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
+      log22.debug(`Failed to validate lastMessageId for session ${session.sessionId}, clearing: ${err}`);
       session.lastMessageId = undefined;
       session.lastMessageTs = undefined;
     }
@@ -68346,7 +68374,7 @@ async function updateStickyMessageImpl(platform, sessions, config) {
       hiddenCleanupDone.add(platform.platformId);
       const existing = stickyPostIds.get(platform.platformId);
       if (existing) {
-        log23.info(`sticky[${platform.platformId}] hidden mode: removing leftover ${formatShortId(existing)}`);
+        log22.info(`sticky[${platform.platformId}] hidden mode: removing leftover ${formatShortId(existing)}`);
         try {
           await platform.unpinPost(existing);
         } catch {}
@@ -68366,63 +68394,63 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     return;
   }
   const platformSessions = [...sessions.values()].filter((s) => s.platformId === platform.platformId);
-  log23.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
+  log22.debug(`updateStickyMessage for ${platform.platformId}, ${platformSessions.length} sessions`);
   for (const s of platformSessions) {
-    log23.debug(`  - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
+    log22.debug(`  - ${s.sessionId}: title="${s.sessionTitle}" firstPrompt="${s.firstPrompt?.substring(0, 30)}..."`);
   }
   await validateLastMessageIds(platform, platformSessions);
   const formatter = platform.getFormatter();
   const content = await buildStickyMessage(sessions, platform.platformId, config, formatter, (threadId) => platform.getThreadLink(threadId));
   const existingPostId = stickyPostIds.get(platform.platformId);
   const shouldBump = needsBump.get(platform.platformId) ?? false;
-  log23.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
+  log22.debug(`existingPostId: ${existingPostId || "(none)"}, needsBump: ${shouldBump}`);
   try {
     if (existingPostId && !shouldBump) {
-      log23.debug(`Updating existing post in place...`);
+      log22.debug(`Updating existing post in place...`);
       try {
         await platform.updatePost(existingPostId, content);
         try {
           await platform.pinPost(existingPostId);
-          log23.debug(`Re-pinned post`);
+          log22.debug(`Re-pinned post`);
         } catch (pinErr) {
-          log23.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
+          log22.debug(`Re-pin failed (might already be pinned): ${pinErr}`);
         }
-        log23.debug(`Updated successfully`);
+        log22.debug(`Updated successfully`);
         return;
       } catch (err) {
-        log23.debug(`Update failed, will create new: ${err}`);
+        log22.debug(`Update failed, will create new: ${err}`);
       }
     }
     needsBump.set(platform.platformId, false);
     if (existingPostId) {
-      log23.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
+      log22.debug(`Unpinning and deleting existing post ${existingPostId.substring(0, 8)}...`);
       try {
         await platform.unpinPost(existingPostId);
-        log23.debug(`Unpinned successfully`);
+        log22.debug(`Unpinned successfully`);
       } catch (err) {
-        log23.debug(`Unpin failed (probably already unpinned): ${err}`);
+        log22.debug(`Unpin failed (probably already unpinned): ${err}`);
       }
       try {
         await platform.deletePost(existingPostId);
-        log23.debug(`Deleted successfully`);
+        log22.debug(`Deleted successfully`);
       } catch (err) {
-        log23.debug(`Delete failed (probably already deleted): ${err}`);
+        log22.debug(`Delete failed (probably already deleted): ${err}`);
       }
       stickyPostIds.delete(platform.platformId);
     }
-    log23.debug(`Creating new post...`);
+    log22.debug(`Creating new post...`);
     const post2 = await platform.createPost(content);
     stickyPostIds.set(platform.platformId, post2.id);
     try {
       await platform.pinPost(post2.id);
-      log23.debug(`Pinned post successfully`);
+      log22.debug(`Pinned post successfully`);
     } catch (err) {
-      log23.debug(`Failed to pin post: ${err}`);
+      log22.debug(`Failed to pin post: ${err}`);
     }
     if (sessionStore) {
       sessionStore.saveStickyPostId(platform.platformId, post2.id);
     }
-    log23.info(`\uD83D\uDCCC Created sticky message for ${platform.platformId}: ${formatShortId(post2.id)}`);
+    log22.info(`\uD83D\uDCCC Created sticky message for ${platform.platformId}: ${formatShortId(post2.id)}`);
     const excludePostIds = new Set;
     if (sessionStore) {
       for (const session of sessionStore.load().values()) {
@@ -68438,10 +68466,10 @@ async function updateStickyMessageImpl(platform, sessions, config) {
     }
     const botUser = await platform.getBotUser();
     cleanupOldStickyMessages(platform, botUser.id, false, excludePostIds).catch((err) => {
-      log23.debug(`Background cleanup failed: ${err}`);
+      log22.debug(`Background cleanup failed: ${err}`);
     });
   } catch (err) {
-    log23.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
+    log22.error(`Failed to update sticky message for ${platform.platformId}`, err instanceof Error ? err : undefined);
   }
 }
 async function updateAllStickyMessages(platforms, sessions, config, overheadByPlatform) {
@@ -68469,7 +68497,7 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
   if (!forceRun) {
     const lastRun = lastCleanupTime.get(platformId) || 0;
     if (now - lastRun < CLEANUP_THROTTLE_MS) {
-      log23.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
+      log22.debug(`Cleanup throttled for ${platformId} (last run ${Math.round((now - lastRun) / 1000)}s ago)`);
       return;
     }
   }
@@ -68479,37 +68507,37 @@ async function cleanupOldStickyMessages(platform, botUserId, forceRun = false, e
     const pinnedPostIds = await platform.getPinnedPosts();
     const recentPinnedIds = pinnedPostIds.filter((id) => id !== currentStickyId && !excludePostIds?.has(id) && isRecentPost(id));
     if (recentPinnedIds.length === 0) {
-      log23.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
+      log22.debug(`No recent pinned posts to check (${pinnedPostIds.length} total, current: ${currentStickyId?.substring(0, 8) || "(none)"})`);
       return;
     }
-    log23.debug(`Checking ${recentPinnedIds.length} recent pinned posts (of ${pinnedPostIds.length} total)`);
+    log22.debug(`Checking ${recentPinnedIds.length} recent pinned posts (of ${pinnedPostIds.length} total)`);
     for (const postId of recentPinnedIds) {
       try {
         const post2 = await platform.getPost(postId);
         if (!post2)
           continue;
         if (post2.userId === botUserId) {
-          log23.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
+          log22.debug(`Cleaning up old sticky: ${postId.substring(0, 8)}...`);
           try {
             await platform.unpinPost(postId);
             await platform.deletePost(postId);
-            log23.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
+            log22.info(`\uD83E\uDDF9 Cleaned up old sticky message: ${postId.substring(0, 8)}...`);
           } catch (err) {
-            log23.debug(`Failed to cleanup ${postId}: ${err}`);
+            log22.debug(`Failed to cleanup ${postId}: ${err}`);
           }
         }
       } catch (err) {
-        log23.debug(`Could not check post ${postId}: ${err}`);
+        log22.debug(`Could not check post ${postId}: ${err}`);
       }
     }
   } catch (err) {
-    log23.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
+    log22.error(`Failed to cleanup old sticky messages`, err instanceof Error ? err : undefined);
   }
 }
 // src/claude/quick-query.ts
 init_spawn();
 init_logger();
-var log24 = createLogger("query");
+var log23 = createLogger("query");
 async function quickQuery(options) {
   const {
     prompt,
@@ -68524,7 +68552,7 @@ async function quickQuery(options) {
   if (systemPrompt) {
     args.push("--system-prompt", systemPrompt);
   }
-  log24.debug(`Quick query: model=${model}, timeout=${timeout2}ms, prompt="${prompt.substring(0, 50)}..."`);
+  log23.debug(`Quick query: model=${model}, timeout=${timeout2}ms, prompt="${prompt.substring(0, 50)}..."`);
   return new Promise((resolve6) => {
     let stdout = "";
     let stderr = "";
@@ -68538,7 +68566,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         proc.kill("SIGTERM");
-        log24.debug(`Quick query timed out after ${timeout2}ms`);
+        log23.debug(`Quick query timed out after ${timeout2}ms`);
         resolve6({
           success: false,
           error: "timeout",
@@ -68556,7 +68584,7 @@ async function quickQuery(options) {
       if (!resolved) {
         resolved = true;
         clearTimeout(timeoutId);
-        log24.debug(`Quick query error: ${err.message}`);
+        log23.debug(`Quick query error: ${err.message}`);
         resolve6({
           success: false,
           error: err.message,
@@ -68570,14 +68598,14 @@ async function quickQuery(options) {
         clearTimeout(timeoutId);
         const durationMs = Date.now() - startTime;
         if (code === 0 && stdout.trim()) {
-          log24.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
+          log23.debug(`Quick query success: ${durationMs}ms, ${stdout.length} chars`);
           resolve6({
             success: true,
             response: stdout.trim(),
             durationMs
           });
         } else {
-          log24.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
+          log23.debug(`Quick query failed: code=${code}, stderr=${stderr.substring(0, 100)}`);
           resolve6({
             success: false,
             error: stderr || `exit code ${code}`,
@@ -68596,7 +68624,7 @@ init_logger();
 import { exec as exec3 } from "child_process";
 import { promisify as promisify3 } from "util";
 var execAsync2 = promisify3(exec3);
-var log25 = createLogger("branch");
+var log24 = createLogger("branch");
 var SUGGESTION_TIMEOUT = 15000;
 var MAX_SUGGESTIONS = 3;
 async function getCurrentBranch3(workingDir) {
@@ -68645,7 +68673,7 @@ function parseBranchSuggestions(response) {
   return lines.slice(0, MAX_SUGGESTIONS);
 }
 async function suggestBranchNames(workingDir, userMessage) {
-  log25.debug(`Suggesting branch names for: "${userMessage.substring(0, 50)}..."`);
+  log24.debug(`Suggesting branch names for: "${userMessage.substring(0, 50)}..."`);
   try {
     const [currentBranch, recentCommits] = await Promise.all([
       getCurrentBranch3(workingDir),
@@ -68659,24 +68687,24 @@ async function suggestBranchNames(workingDir, userMessage) {
       workingDir
     });
     if (!result.success || !result.response) {
-      log25.debug(`Branch suggestion failed: ${result.error || "no response"}`);
+      log24.debug(`Branch suggestion failed: ${result.error || "no response"}`);
       return [];
     }
     const suggestions = parseBranchSuggestions(result.response);
-    log25.debug(`Got ${suggestions.length} branch suggestions: ${suggestions.join(", ")}`);
+    log24.debug(`Got ${suggestions.length} branch suggestions: ${suggestions.join(", ")}`);
     return suggestions;
   } catch (err) {
-    log25.debug(`Branch suggestion error: ${err}`);
+    log24.debug(`Branch suggestion error: ${err}`);
     return [];
   }
 }
 
 // src/operations/worktree/handler.ts
 init_worktree();
-import { randomUUID as randomUUID3 } from "crypto";
+import { randomUUID as randomUUID4 } from "crypto";
 init_logger();
-var log26 = createLogger("worktree");
-var sessionLog2 = createSessionLog(log26);
+var log25 = createLogger("worktree");
+var sessionLog2 = createSessionLog(log25);
 function parseWorktreeError(error) {
   const message = error instanceof Error ? error.message : String(error);
   const lowerMessage = message.toLowerCase();
@@ -68920,7 +68948,7 @@ async function createAndSwitchToWorktree(session, branch, username, options) {
         transitionTo(session, "restarting");
         await session.claude.kill();
         await options.flush(session);
-        const newSessionId = randomUUID3();
+        const newSessionId = randomUUID4();
         session.claudeSessionId = newSessionId;
         const needsTitlePrompt = !session.sessionTitle;
         const memoryConfig = options.getPlatformMemoryConfig(session.platformId);
@@ -69019,7 +69047,7 @@ ${fmt.formatItalic("Claude Code restarted in the worktree")}`);
       transitionTo(session, "restarting");
       await session.claude.kill();
       await options.flush(session);
-      const newSessionId = randomUUID3();
+      const newSessionId = randomUUID4();
       session.claudeSessionId = newSessionId;
       const needsTitlePrompt = !session.sessionTitle;
       const memoryConfig = options.getPlatformMemoryConfig(session.platformId);
@@ -69258,8 +69286,8 @@ async function cleanupWorktreeCommand(session, username, hasOtherSessionsUsingWo
 }
 // src/operations/events/handler.ts
 init_logger();
-var log27 = createLogger("events");
-var sessionLog3 = createSessionLog(log27);
+var log26 = createLogger("events");
+var sessionLog3 = createSessionLog(log26);
 function detectAndExecuteClaudeCommands(text, session, ctx) {
   const parsed = parseClaudeCommand(text);
   if (parsed && isClaudeAllowedCommand(parsed.command)) {
@@ -69392,7 +69420,11 @@ function handleEventPostProcessing(session, event, ctx, mainHandling) {
     ctx.ops.emitSessionUpdate(session.sessionId, { status: getSessionStatus(session) });
     updateUsageStats(session, event, ctx);
     if (mainHandling) {
-      mainHandling.catch(() => {}).then(() => ctx.ops.persistSession(session));
+      mainHandling.catch(() => {}).then(() => {
+        if (!ctx.state.sessions.has(session.sessionId))
+          return;
+        ctx.ops.persistSession(session);
+      });
     } else {
       ctx.ops.persistSession(session);
     }
@@ -69568,6 +69600,56 @@ function updateUsageFromStatusLine(session) {
     sessionLog3(session).debug(`Updated from status line: context ${contextTokens}/${session.usageStats.contextWindowSize} (${contextPct}%)`);
   }
 }
+// src/operations/monitor/handler.ts
+init_logger();
+var log27 = createLogger("monitor");
+var DEFAULT_INTERVAL_MS2 = 60 * 1000;
+
+class SessionMonitor {
+  intervalMs;
+  sessionTimeoutMs;
+  sessionWarningMs;
+  getContext;
+  getSessionCount;
+  updateStickyMessage;
+  timer = null;
+  isRunning = false;
+  constructor(options) {
+    this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS2;
+    this.sessionTimeoutMs = options.sessionTimeoutMs;
+    this.sessionWarningMs = options.sessionWarningMs;
+    this.getContext = options.getContext;
+    this.getSessionCount = options.getSessionCount;
+    this.updateStickyMessage = options.updateStickyMessage;
+  }
+  start() {
+    if (this.isRunning) {
+      log27.debug("Session monitor already running");
+      return;
+    }
+    this.isRunning = true;
+    log27.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
+    this.timer = setInterval(() => {
+      this.runCheck().catch((err) => {
+        log27.error(`Error during session monitoring: ${err}`);
+      });
+    }, this.intervalMs);
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this.isRunning = false;
+    log27.debug("Session monitor stopped");
+  }
+  async runCheck() {
+    await cleanupIdleSessions(this.sessionTimeoutMs, this.sessionWarningMs, this.getContext());
+    if (this.getSessionCount() > 0) {
+      await this.updateStickyMessage();
+    }
+  }
+}
 // src/operations/session-context/types.ts
 function createSessionContext(config, state, ops) {
   return {
@@ -69969,9 +70051,90 @@ async function suggestSessionMetadata(context) {
     return null;
   }
 }
+// src/routines/parser.ts
+init_logger();
+var log31 = createLogger("routines");
+var PARSE_TIMEOUT_MS = 15000;
+function hostTimezone() {
+  return Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
+}
+function buildParsePrompt(request, defaultTimezone) {
+  return `Parse this scheduled-routine request from a chat user into JSON.
+
+Request: ${request}
+
+Output ONLY a JSON object, no other text, with exactly these fields:
+- "name": short descriptive name for the routine (max 6 words)
+- "prompt": the task to perform on each run, as an instruction (everything that is not the schedule)
+- "preset": one of "hourly", "daily", "weekdays", "weekly" (the closest match; sub-hourly is not supported — if the user asked for more often than hourly, use "hourly")
+- "time": "HH:MM" 24-hour (omit for hourly)
+- "weekday": 1-7 where 1=Monday (only for weekly)
+- "timezone": IANA timezone ONLY if the user named one (e.g. "9am Pacific" -> "America/Los_Angeles"); otherwise omit and ${defaultTimezone} will be used
+
+If the request is not actually asking for a recurring schedule, output exactly: {"error": "reason"}`;
+}
+function extractJsonObject(output) {
+  const start = output.indexOf("{");
+  const end = output.lastIndexOf("}");
+  if (start < 0 || end <= start)
+    return;
+  try {
+    const parsed = JSON.parse(output.slice(start, end + 1));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
+function validateParsedRoutine(raw, defaultTimezone) {
+  if (typeof raw.error === "string" && raw.error) {
+    return { ok: false, error: raw.error };
+  }
+  const name = typeof raw.name === "string" ? raw.name.trim() : "";
+  const prompt = typeof raw.prompt === "string" ? raw.prompt.trim() : "";
+  const preset = raw.preset;
+  if (!name)
+    return { ok: false, error: "could not derive a routine name" };
+  if (!prompt)
+    return { ok: false, error: "could not tell what the routine should do" };
+  if (!SCHEDULE_PRESETS.includes(preset)) {
+    return { ok: false, error: `could not map the schedule to ${SCHEDULE_PRESETS.join("/")}` };
+  }
+  const timezoneDefaulted = !(typeof raw.timezone === "string" && raw.timezone);
+  const timezone = timezoneDefaulted ? defaultTimezone : raw.timezone;
+  if (!isValidTimezone(timezone)) {
+    return { ok: false, error: `unknown timezone "${String(raw.timezone)}"` };
+  }
+  const schedule = {
+    preset,
+    timezone,
+    ...preset !== "hourly" && typeof raw.time === "string" ? { time: raw.time } : {},
+    ...preset === "weekly" && typeof raw.weekday === "number" ? { weekday: raw.weekday } : {}
+  };
+  const scheduleError = validateSchedule(schedule);
+  if (scheduleError)
+    return { ok: false, error: scheduleError };
+  return { ok: true, parsed: { name, prompt, schedule }, timezoneDefaulted };
+}
+async function parseRoutineRequest(request, defaultTimezone = hostTimezone()) {
+  const result = await quickQuery({
+    prompt: buildParsePrompt(request, defaultTimezone),
+    model: "haiku",
+    timeout: PARSE_TIMEOUT_MS
+  });
+  if (!result.success || !result.response) {
+    log31.debug(`Routine parse quickQuery failed: ${result.error ?? "no response"}`);
+    return { ok: false, error: "could not reach the parsing model — try again in a moment" };
+  }
+  const raw = extractJsonObject(result.response);
+  if (!raw) {
+    return { ok: false, error: 'could not understand the schedule — try e.g. "every weekday at 9:00, <task>"' };
+  }
+  return validateParsedRoutine(raw, defaultTimezone);
+}
+
 // src/operations/commands/handler.ts
-var log31 = createLogger("commands");
-var sessionLog5 = createSessionLog(log31);
+var log32 = createLogger("commands");
+var sessionLog5 = createSessionLog(log32);
 function sessionAccountOption(session, ctx) {
   if (!session.claudeAccountId)
     return;
@@ -70148,7 +70311,7 @@ async function changeDirectory(session, newDir, username, ctx) {
     sessionLog5(session).debug(`Stored work summary for context preservation`);
   }
   session.workingDir = absoluteDir;
-  const newSessionId = randomUUID4();
+  const newSessionId = randomUUID5();
   session.claudeSessionId = newSessionId;
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(session.platformId);
   const appendSystemPrompt = await buildAppendSystemPrompt(session.platform, session.platformId, absoluteDir, session.threadId, session.startedBy, session.sessionAllowedUsers, CHAT_PLATFORM_PROMPT, ctx.state.githubEmailsStore, memoryConfig.enabled && memoryConfig.channelLayer ? ctx.state.memoryStore : null, { userAttribution: session.userAttribution });
@@ -70438,6 +70601,125 @@ ${list}${more}`);
       await post(session, "warning", `\uD83E\uDDE0 No matching entry. Use ${formatter.formatCode("!memory")} to list entries, then ${formatter.formatCode("!memory forget <number>")}.`);
   }
 }
+async function requireRoutinesEnabled(session, ctx) {
+  if (ctx.ops.isRoutinesEnabled(session.platformId))
+    return true;
+  await post(session, "info", `\uD83D\uDD58 Routines are disabled for this platform (see the \`routines\` option in config.yaml).`);
+  return false;
+}
+async function createRoutine(session, request, username, ctx, parse = parseRoutineRequest) {
+  if (!await requireRoutinesEnabled(session, ctx))
+    return;
+  if (!await requireSessionOwner(session, username, "create routines"))
+    return;
+  const formatter = session.platform.getFormatter();
+  const trimmed = request.trim();
+  if (!trimmed) {
+    await post(session, "warning", `Usage: ${formatter.formatCode("!routine every weekday at 9:00, <task>")}`);
+    return;
+  }
+  await post(session, "info", `\uD83D\uDD58 Parsing the schedule...`);
+  const result = await parse(trimmed, hostTimezone());
+  if (!result.ok) {
+    await post(session, "warning", `\uD83D\uDD58 Could not create a routine: ${result.error}`);
+    sessionLog5(session).warn(`\uD83D\uDD58 Routine parse failed for @${username}: ${result.error}`);
+    return;
+  }
+  const { parsed, timezoneDefaulted } = result;
+  const tzNote = timezoneDefaulted ? `
+${formatter.formatItalic(`Timezone defaulted to the bot host's ${parsed.schedule.timezone} — name one explicitly ("9am Pacific") to override.`)}` : "";
+  const confirmPost = await postInteractiveAndRegister(session, `\uD83D\uDD58 ${formatter.formatBold(`Create routine "${parsed.name}"?`)}
+` + `${formatter.formatBold("Schedule:")} ${describeSchedule(parsed.schedule)}
+` + `${formatter.formatBold("Task:")} ${parsed.prompt}${tzNote}
+
+` + `${formatter.formatItalic("Each run starts a full Claude session in a new thread. React \uD83D\uDC4D to save or \uD83D\uDC4E to discard.")}`, ["+1", "-1"], (postId, threadId) => ctx.ops.registerPost(postId, threadId));
+  session.messageManager?.setPendingRoutinePrompt({
+    postId: confirmPost.id,
+    parsed,
+    requestedBy: username
+  });
+  sessionLog5(session).info(`\uD83D\uDD58 Routine proposal posted for @${username}: "${parsed.name}"`);
+}
+function routineByIndex(ctx, platformId, arg) {
+  if (!/^\d+$/.test(arg))
+    return;
+  const list = ctx.state.routinesStore.list(platformId);
+  return list[parseInt(arg, 10) - 1];
+}
+async function manageRoutines(session, args, username, ctx) {
+  if (!await requireRoutinesEnabled(session, ctx))
+    return;
+  const formatter = session.platform.getFormatter();
+  const platformId = session.platformId;
+  const trimmed = args?.trim();
+  if (!trimmed) {
+    const routines = ctx.state.routinesStore.list(platformId);
+    if (routines.length === 0) {
+      await post(session, "info", `\uD83D\uDD58 No routines yet. Create one with ${formatter.formatCode("!routine every weekday at 9:00, <task>")}.`);
+      return;
+    }
+    const lines = routines.map((r, i) => {
+      const status = r.enabled ? "" : " — ⏸️ paused";
+      const last = r.lastRunAt ? ` · last run ${r.lastRunAt.slice(0, 16).replace("T", " ")}Z (${r.lastRunStatus})` : "";
+      return `${i + 1}. ${formatter.formatBold(r.name)} — ${describeSchedule(r.schedule)} · by ${formatter.formatCode("@" + r.createdBy)}${status}${last}`;
+    });
+    await post(session, "info", `\uD83D\uDD58 ${formatter.formatBold(`Routines (${routines.length})`)} — each run starts a full Claude session in a new thread:
+
+` + `${lines.join(`
+`)}
+
+` + `${formatter.formatItalic(`Manage with ${"`!routines pause|resume|delete|run <n>`"}.`)}`);
+    session.threadLogger?.logCommand("routines", "list", username);
+    return;
+  }
+  const match = trimmed.match(/^(pause|resume|delete|run)\s+(\d+)$/i);
+  if (!match) {
+    await post(session, "warning", `\uD83D\uDD58 Usage: ${formatter.formatCode("!routines")} or ${formatter.formatCode("!routines pause|resume|delete|run <n>")}`);
+    return;
+  }
+  const [, action, indexArg] = match;
+  const routine = routineByIndex(ctx, platformId, indexArg);
+  if (!routine) {
+    await post(session, "warning", `\uD83D\uDD58 No routine ${indexArg}. See ${formatter.formatCode("!routines")}.`);
+    return;
+  }
+  const lowered = action.toLowerCase();
+  if (lowered !== "run" && !await requireSessionOwner(session, username, "manage routines")) {
+    return;
+  }
+  if (lowered === "run" && !session.platform.isUserAllowed(username)) {
+    await post(session, "warning", `\uD83D\uDD58 Only platform-allowed users can run routines (${formatter.formatCode("@" + username)} is invited to this session only).`);
+    return;
+  }
+  switch (lowered) {
+    case "pause":
+      await ctx.state.routinesStore.update(platformId, routine.id, { enabled: false });
+      await post(session, "success", `⏸️ Routine ${formatter.formatBold(routine.name)} paused.`);
+      break;
+    case "resume":
+      await ctx.state.routinesStore.update(platformId, routine.id, { enabled: true, consecutiveFailures: 0 });
+      await post(session, "success", `▶️ Routine ${formatter.formatBold(routine.name)} resumed.`);
+      break;
+    case "delete":
+      await ctx.state.routinesStore.remove(platformId, routine.id);
+      await post(session, "success", `\uD83D\uDDD1️ Routine ${formatter.formatBold(routine.name)} deleted.`);
+      break;
+    case "run": {
+      await post(session, "info", `\uD83D\uDD58 Running ${formatter.formatBold(routine.name)} now — it will post in a new thread.`);
+      const status = await ctx.ops.fireRoutineNow(platformId, routine);
+      if (status === "skipped") {
+        await post(session, "warning", `\uD83D\uDD58 Could not run now (session limit reached or platform busy) — try again shortly.`);
+      } else if (status === "unauthorized") {
+        await post(session, "warning", `\uD83D\uDD58 The routine's creator ${formatter.formatCode("@" + routine.createdBy)} is no longer authorized — routine disabled.`);
+      } else if (status === "failed") {
+        await post(session, "warning", `\uD83D\uDD58 The run failed to start — check the bot logs.`);
+      }
+      break;
+    }
+  }
+  sessionLog5(session).info(`\uD83D\uDD58 @${username}: !routines ${lowered} ${indexArg} ("${routine.name}")`);
+  session.threadLogger?.logCommand("routines", `${lowered} ${indexArg}`, username);
+}
 async function setSessionPermissionMode(session, username, mode, ctx) {
   if (!await requireSessionOwner(session, username, "change permissions")) {
     return;
@@ -70738,7 +71020,7 @@ init_worktree();
 
 // src/memory/distiller.ts
 init_logger();
-var log32 = createLogger("memory");
+var log33 = createLogger("memory");
 var MIN_THREAD_MESSAGES = 4;
 var DISTILL_MESSAGE_LIMIT = 30;
 var MESSAGE_CHAR_CAP = 500;
@@ -70785,10 +71067,10 @@ function scheduleDistillation(session, ctx, reason) {
   const store = ctx.state.memoryStore;
   distillThread(store, platformId, threadId, platform).then((added) => {
     if (added > 0) {
-      log32.debug(`Distilled ${added} memory entries from ${platformId}:${threadId} (${reason})`);
+      log33.debug(`Distilled ${added} memory entries from ${platformId}:${threadId} (${reason})`);
     }
   }).catch((err) => {
-    log32.debug(`Distillation failed for ${platformId}:${threadId}: ${err.message}`);
+    log33.debug(`Distillation failed for ${platformId}:${threadId}: ${err.message}`);
   });
 }
 async function distillThread(store, platformId, threadId, platform) {
@@ -70815,8 +71097,8 @@ async function distillThread(store, platformId, threadId, platform) {
 }
 
 // src/session/lifecycle.ts
-var log33 = createLogger("lifecycle");
-var sessionLog6 = createSessionLog(log33);
+var log34 = createLogger("lifecycle");
+var sessionLog6 = createSessionLog(log34);
 function mutableSessions(ctx) {
   return ctx.state.sessions;
 }
@@ -70920,7 +71202,7 @@ async function createSessionDecisionBridge(ref) {
       return messageManager.handleBridgeRequest(request, signal);
     });
   } catch (err) {
-    log33.warn(`Decision bridge unavailable — falling back to legacy MCP prompts: ${err}`);
+    log34.warn(`Decision bridge unavailable — falling back to legacy MCP prompts: ${err}`);
     return null;
   }
 }
@@ -70988,6 +71270,28 @@ function createMessageManager(session, ctx) {
       sessionLog6(session).info(`@${fromUser} invited to session by @${approvedBy}`);
     }
   });
+  messageManager.events.on("routine-prompt:complete", async ({ approved, parsed, requestedBy, postId }) => {
+    session.threadLogger?.logCommand("routine", approved ? "created" : "discarded", requestedBy);
+    if (!approved) {
+      sessionLog6(session).info(`\uD83D\uDD58 Routine "${parsed.name}" discarded before saving`);
+      return;
+    }
+    let result;
+    try {
+      result = await ctx.state.routinesStore.add(session.platformId, { name: parsed.name, prompt: parsed.prompt, schedule: parsed.schedule, createdBy: requestedBy }, ctx.config.maxRoutines);
+    } catch (err) {
+      result = { ok: false, error: `could not write the routines file (${err.message})` };
+    }
+    const formatter = session.platform.getFormatter();
+    if (result.ok) {
+      const position = ctx.state.routinesStore.list(session.platformId).length;
+      await withErrorHandling(() => session.platform.updatePost(postId, `✅ ${formatter.formatBold(`Routine ${position}: ${result.routine.name}`)} saved — it will post its runs as new threads in this channel. ` + `${formatter.formatItalic(`Manage with ${"`!routines`"}. Each run starts a full Claude session.`)}`), { action: "Update routine confirmation post", session });
+      sessionLog6(session).info(`\uD83D\uDD58 Routine "${result.routine.name}" saved by @${requestedBy}`);
+    } else {
+      await withErrorHandling(() => session.platform.updatePost(postId, `⚠️ Could not save routine: ${result.error}`), { action: "Update routine confirmation post", session });
+      sessionLog6(session).warn(`\uD83D\uDD58 Routine save failed: ${result.error}`);
+    }
+  });
   messageManager.events.on("context-prompt:complete", async ({ selection, queuedPrompt, queuedByUsername, queuedFiles: _queuedFiles, threadMessageCount: _threadMessageCount }) => {
     const userTurn = formatUserTurn(queuedPrompt, queuedByUsername, shouldAttribute(session.userAttribution, session.sessionAllowedUsers.size));
     let messageToSend = userTurn;
@@ -71185,7 +71489,7 @@ function resumeSessionHeaderMode(persisted, platformConfigured) {
 function resolveSessionHeaderMode(configured, replyToPostId, platformId) {
   const mode = configured ?? DEFAULT_OVERHEAD_VISIBILITY;
   if (mode === "hidden" && !replyToPostId) {
-    log33.error(`sessionHeader: hidden requires a replyToPostId for ${platformId}; ` + `downgrading this session to 'minimal' so the header post is still short.`);
+    log34.error(`sessionHeader: hidden requires a replyToPostId for ${platformId}; ` + `downgrading this session to 'minimal' so the header post is still short.`);
     return "minimal";
   }
   return mode;
@@ -71204,7 +71508,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
     throw new Error(`Platform '${platformId}' not found. Call addPlatform() first.`);
   }
   if (!isAuthorizedForSession({ username, platform, sessionAllowedUsers: undefined })) {
-    log33.warn(`auth.denied.startSession: @${username || "unknown"} not authorized to start session in ${threadId.substring(0, 8)}...`);
+    log34.warn(`auth.denied.startSession: @${username || "unknown"} not authorized to start session in ${threadId.substring(0, 8)}...`);
     return;
   }
   const activeOrPending = ctx.state.sessions.size + pendingStartsCount;
@@ -71233,7 +71537,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
   const actualThreadId = replyToPostId || (startPost ? startPost.id : "");
   const sessionId = ctx.ops.getSessionId(platformId, actualThreadId);
   platform.sendTyping(actualThreadId);
-  const claudeSessionId = randomUUID5();
+  const claudeSessionId = randomUUID6();
   let workingDir = ctx.config.workingDir;
   let permissionMode = ctx.config.permissionMode;
   let forceInteractivePermissions = false;
@@ -71265,17 +71569,17 @@ async function startSession(options, username, displayName, replyToPostId, platf
       return;
     }
     workingDir = resolvedDir;
-    log33.info(`Starting session in directory: ${workingDir} (from !cd command)`);
+    log34.info(`Starting session in directory: ${workingDir} (from !cd command)`);
   }
   if (initialOptions?.permissionMode) {
     permissionMode = initialOptions.permissionMode;
     forceInteractivePermissions = permissionMode === "default";
     sessionPermissionModeOverride = permissionMode;
-    log33.info(`Starting session with permission mode "${permissionMode}" (from !permissions command)`);
+    log34.info(`Starting session with permission mode "${permissionMode}" (from !permissions command)`);
   } else if (initialOptions?.forceInteractivePermissions) {
     forceInteractivePermissions = true;
     permissionMode = "default";
-    log33.info(`Starting session with interactive permissions (from !permissions command)`);
+    log34.info(`Starting session with interactive permissions (from !permissions command)`);
   }
   const userAttribution = ctx.config.userAttribution ?? true;
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(platformId);
@@ -71286,7 +71590,7 @@ async function startSession(options, username, displayName, replyToPostId, platf
     balanceByUsage: true
   });
   if (claudeAccount) {
-    log33.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
+    log34.info(`Session ${sessionId.substring(0, 20)} reserved Claude account "${claudeAccount.id}"`);
   }
   const bridgeSessionRef = {};
   const decisionBridge = await createSessionDecisionBridge(bridgeSessionRef);
@@ -71417,28 +71721,28 @@ async function resumeSession(state, ctx) {
       !state.claudeSessionId && "claudeSessionId",
       !state.workingDir && "workingDir"
     ].filter(Boolean).join(", ");
-    log33.warn(`Skipping session with missing required fields: ${missing}`);
+    log34.warn(`Skipping session with missing required fields: ${missing}`);
     return;
   }
   const shortId = state.threadId.substring(0, 8);
   const platforms = ctx.state.platforms;
   const platform = platforms.get(state.platformId);
   if (!platform) {
-    log33.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
+    log34.warn(`Platform ${state.platformId} not registered, skipping resume for ${shortId}...`);
     return;
   }
   const threadPost = await platform.getPost(state.threadId);
   if (!threadPost) {
-    log33.warn(`Thread ${shortId}... deleted, skipping resume`);
+    log34.warn(`Thread ${shortId}... deleted, skipping resume`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     return;
   }
   if (ctx.state.sessions.size >= ctx.config.maxSessions) {
-    log33.warn(`Max sessions reached, skipping resume for ${shortId}...`);
+    log34.warn(`Max sessions reached, skipping resume for ${shortId}...`);
     return;
   }
   if (!existsSync13(state.workingDir)) {
-    log33.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
+    log34.warn(`Working directory ${state.workingDir} no longer exists, skipping resume for ${shortId}...`);
     ctx.state.sessionStore.remove(`${state.platformId}:${state.threadId}`);
     const resumeFormatter = platform.getFormatter();
     const tempSession = {
@@ -71461,7 +71765,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
   const appendSystemPrompt = await buildAppendSystemPrompt(platform, state.platformId, state.workingDir, state.threadId, state.startedBy, state.sessionAllowedUsers || [state.startedBy], CHAT_PLATFORM_PROMPT, ctx.state.githubEmailsStore, memoryConfig.enabled && memoryConfig.channelLayer ? ctx.state.memoryStore : null, { userAttribution });
   const claudeAccount = ctx.ops.acquireClaudeAccount(state.claudeAccountId, state.threadId);
   if (state.claudeAccountId && !claudeAccount) {
-    log33.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
+    log34.warn(`Persisted session referenced Claude account "${state.claudeAccountId}" ` + `which is no longer configured — resuming under default env`);
   }
   const resumeBridgeRef = {};
   const resumeBridge = await createSessionDecisionBridge(resumeBridgeRef);
@@ -71544,7 +71848,7 @@ Please start a new session.`), { action: "Post resume failure notification" });
         worktreePath: detected.worktreePath,
         branch: detected.branch
       };
-      log33.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
+      log34.info(`Auto-detected worktree info for resumed session: branch=${detected.branch}`);
     }
   }
   session.messageManager = createMessageManager(session, ctx);
@@ -71603,7 +71907,7 @@ ${sessionFormatter.formatItalic("Reconnected to Claude session. You can continue
     await postResumeCoAuthorOnboarding(session, ctx);
     ctx.ops.persistSession(session);
   } catch (err) {
-    log33.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
+    log34.error(`Failed to resume session ${shortId}`, err instanceof Error ? err : undefined);
     session.messageManager?.dispose();
     session.decisionBridge?.close();
     session.decisionBridge = undefined;
@@ -71646,28 +71950,28 @@ async function resumePausedSession(threadId, message, files, ctx, username) {
   const persisted = ctx.state.sessionStore.load();
   const state = findPersistedByThreadId(persisted, threadId);
   if (!state) {
-    log33.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
+    log34.debug(`No persisted session found for ${threadId.substring(0, 8)}...`);
     return;
   }
   const shortId = threadId.substring(0, 8);
   const platform = ctx.state.platforms.get(state.platformId);
   if (!platform) {
-    log33.warn(`auth.denied.resume: platform '${state.platformId}' not found for ${shortId}...`);
+    log34.warn(`auth.denied.resume: platform '${state.platformId}' not found for ${shortId}...`);
     return;
   }
   const sessionAllowedUsers = new Set(state.sessionAllowedUsers || [state.startedBy].filter(Boolean));
   if (!isAuthorizedForSession({ username, platform, sessionAllowedUsers })) {
-    log33.warn(`auth.denied.resume: @${username || "unknown"} not authorized to resume ${shortId}...`);
+    log34.warn(`auth.denied.resume: @${username || "unknown"} not authorized to resume ${shortId}...`);
     return;
   }
-  log33.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
+  log34.info(`\uD83D\uDD04 Resuming paused session ${shortId}... for new message`);
   await resumeSession(state, ctx);
   const session = ctx.ops.findSessionByThreadId(threadId);
   if (session && session.claude.isRunning() && session.messageManager) {
     session.messageCount++;
     await session.messageManager.handleUserMessage(message, files, username);
   } else {
-    log33.warn(`Failed to resume session ${shortId}..., could not send message`);
+    log34.warn(`Failed to resume session ${shortId}..., could not send message`);
   }
 }
 async function handleExit(sessionId, code, ctx, source) {
@@ -71675,7 +71979,7 @@ async function handleExit(sessionId, code, ctx, source) {
   const shortId = sessionId.substring(0, 8);
   sessionLog6(session).debug(`handleExit called code=${code} isShuttingDown=${ctx.state.isShuttingDown}`);
   if (!session) {
-    log33.debug(`Session ${shortId}... not found (already cleaned up)`);
+    log34.debug(`Session ${shortId}... not found (already cleaned up)`);
     return;
   }
   if (source && session.claude !== source) {
@@ -71876,37 +72180,338 @@ async function cleanupIdleSessions(timeoutMs, warningMs, ctx) {
   }
 }
 
-// src/operations/monitor/handler.ts
-var log34 = createLogger("monitor");
-var DEFAULT_INTERVAL_MS = 60 * 1000;
+// src/routines/runner.ts
+init_logger();
+var log35 = createLogger("routines");
+async function fireRoutine(routine, platformId, ctx) {
+  const platforms = ctx.state.platforms;
+  const platform = platforms.get(platformId);
+  if (!platform) {
+    log35.debug(`Routine "${routine.name}": platform ${platformId} not registered — skipping`);
+    return "skipped";
+  }
+  if (!isAuthorizedForSession({ username: routine.createdBy, platform, sessionAllowedUsers: undefined })) {
+    log35.warn(`Routine "${routine.name}": creator @${routine.createdBy} no longer authorized on ${platformId}`);
+    return "unauthorized";
+  }
+  if (ctx.state.sessions.size >= ctx.config.maxSessions) {
+    log35.debug(`Routine "${routine.name}": at MAX_SESSIONS — skipping this tick`);
+    return "skipped";
+  }
+  const formatter = platform.getFormatter();
+  const rootPost = await platform.createPost(`\uD83D\uDD58 ${formatter.formatBold(`Routine: ${routine.name}`)}
+` + `${formatter.formatItalic(`${describeSchedule(routine.schedule)} · created by`)} ${formatter.formatUserMention(routine.createdBy)}`);
+  await startSession({
+    prompt: `[Scheduled routine "${routine.name}" — started automatically on its schedule, not by a live user. ` + `Complete the task and post the result in this thread.]
 
-class SessionMonitor {
+${routine.prompt}`,
+    skipWorktreePrompt: true
+  }, routine.createdBy, undefined, rootPost.id, platformId, ctx);
+  if (!ctx.state.sessions.has(ctx.ops.getSessionId(platformId, rootPost.id))) {
+    log35.debug(`Routine "${routine.name}": startSession declined to start a session — skipping this tick`);
+    return "skipped";
+  }
+  return "ok";
+}
+
+// src/claude/account-pool.ts
+init_logger();
+
+// src/claude/usage-probe.ts
+init_spawn();
+init_logger();
+var log36 = createLogger("usage-probe");
+var DEFAULT_USAGE_PROBE_TIMEOUT_MS = 30000;
+function parseUsageOutput(text) {
+  if (!text)
+    return null;
+  const sessionMatch = text.match(/Current session:\s*(\d+)%\s*used(?:\s*·\s*resets\s*([^\n]+?))?\s*(?:\n|$)/i);
+  const weekAllMatch = text.match(/Current week(?: \(all models\))?:\s*(\d+)%\s*used(?:\s*·\s*resets\s*([^\n]+?))?\s*(?:\n|$)/i);
+  if (!sessionMatch && !weekAllMatch)
+    return null;
+  const sessionPct = sessionMatch ? clampPct(Number(sessionMatch[1])) : 0;
+  const weekAllModelsPct = weekAllMatch ? clampPct(Number(weekAllMatch[1])) : 0;
+  let weekPerModelPct = null;
+  const perModelRe = /Current week \((?!all models\))[^)]+\):\s*(\d+)%\s*used/gi;
+  for (const m of text.matchAll(perModelRe)) {
+    const pct = clampPct(Number(m[1]));
+    weekPerModelPct = weekPerModelPct === null ? pct : Math.max(weekPerModelPct, pct);
+  }
+  return {
+    sessionPct,
+    weekAllModelsPct,
+    weekPerModelPct,
+    sessionResetsAt: sessionMatch?.[2]?.trim() || null,
+    weekResetsAt: weekAllMatch?.[2]?.trim() || null
+  };
+}
+function usageLoadScore(usage) {
+  return Math.max(usage.sessionPct, usage.weekAllModelsPct, usage.weekPerModelPct ?? 0);
+}
+function clampPct(n) {
+  if (!Number.isFinite(n))
+    return 0;
+  return Math.max(0, Math.min(100, Math.round(n)));
+}
+async function probeAccountUsage(account, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_USAGE_PROBE_TIMEOUT_MS;
+  const claudePath = getClaudePath();
+  const env4 = buildClaudeChildEnv(process.env, account);
+  return new Promise((resolve7) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve7(value);
+    };
+    let child;
+    try {
+      child = crossSpawn(claudePath, ["-p", "/usage", "--output-format", "json"], {
+        env: env4,
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+    } catch (err) {
+      log36.warn(`Failed to spawn /usage probe for "${account.id}": ${err}`);
+      resolve7(null);
+      return;
+    }
+    const timer = setTimeout(() => {
+      log36.warn(`/usage probe for "${account.id}" timed out after ${timeoutMs}ms`);
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+      finish(null);
+    }, timeoutMs);
+    let stdout = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", () => {});
+    child.on("error", (err) => {
+      log36.warn(`/usage probe for "${account.id}" errored: ${err}`);
+      finish(null);
+    });
+    child.on("close", () => {
+      const usage = extractUsage(stdout);
+      if (!usage) {
+        log36.debug(`/usage probe for "${account.id}" returned no parseable usage`);
+      }
+      finish(usage);
+    });
+  });
+}
+function extractUsage(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed)
+    return null;
+  let text = trimmed;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed.result === "string") {
+      text = parsed.result;
+    }
+  } catch {}
+  return parseUsageOutput(text);
+}
+
+// src/claude/account-pool.ts
+var log37 = createLogger("account-pool");
+var ACTIVE_SESSION_LOAD_PENALTY = 5;
+function hashThreadId(threadId) {
+  let h = 2166136261;
+  for (let i = 0;i < threadId.length; i++) {
+    h ^= threadId.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+
+class AccountPool {
+  accounts;
+  byId;
+  orderIndex;
+  activeCounts = new Map;
+  coolingUntil = new Map;
+  usage = new Map;
+  rrCursor = 0;
+  constructor(accounts) {
+    this.accounts = (accounts ?? []).filter((acc) => {
+      const hasAuth = !!acc.home || !!acc.apiKey;
+      if (!hasAuth) {
+        log37.warn(`Claude account ${acc.id} has neither home nor apiKey — ignoring`);
+        return false;
+      }
+      if (acc.home && acc.apiKey) {
+        log37.warn(`Claude account ${acc.id} has both home and apiKey set — must choose one; ignoring`);
+        return false;
+      }
+      return true;
+    });
+    this.byId = new Map(this.accounts.map((acc) => [acc.id, acc]));
+    this.orderIndex = new Map(this.accounts.map((acc, i) => [acc.id, i]));
+    for (const acc of this.accounts) {
+      this.activeCounts.set(acc.id, 0);
+      this.usage.set(acc.id, null);
+    }
+  }
+  get isEmpty() {
+    return this.accounts.length === 0;
+  }
+  get size() {
+    return this.accounts.length;
+  }
+  get all() {
+    return this.accounts;
+  }
+  acquire(preferredId, threadId, opts) {
+    if (this.isEmpty)
+      return null;
+    if (preferredId) {
+      const preferred = this.byId.get(preferredId);
+      if (preferred) {
+        this.incrementActive(preferred.id);
+        return preferred;
+      }
+      log37.warn(`Preferred account "${preferredId}" not in pool — falling back to usage balancing`);
+    }
+    const now = Date.now();
+    const n = this.accounts.length;
+    if (threadId && !opts?.balanceByUsage) {
+      const sticky = this.accounts[hashThreadId(threadId) % n];
+      const cooling = this.coolingUntil.get(sticky.id) ?? 0;
+      if (cooling <= now) {
+        this.incrementActive(sticky.id);
+        return sticky;
+      }
+    }
+    const chosen = this.selectLeastLoaded(now);
+    if (!chosen) {
+      log37.warn(`All ${n} accounts are in rate-limit cooldown`);
+      return null;
+    }
+    this.incrementActive(chosen.id);
+    return chosen;
+  }
+  selectLeastLoaded(now) {
+    const n = this.accounts.length;
+    let best = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+    let bestIdx = -1;
+    for (let k = 0;k < n; k++) {
+      const idx = (this.rrCursor + k) % n;
+      const acc = this.accounts[idx];
+      if ((this.coolingUntil.get(acc.id) ?? 0) > now)
+        continue;
+      const score = this.effectiveLoad(acc.id);
+      if (best === null || score < bestScore) {
+        best = acc;
+        bestScore = score;
+        bestIdx = idx;
+      }
+    }
+    if (bestIdx >= 0)
+      this.rrCursor = (bestIdx + 1) % n;
+    return best;
+  }
+  loadScore(accountId) {
+    const u = this.usage.get(accountId);
+    return u ? usageLoadScore(u) : Number.POSITIVE_INFINITY;
+  }
+  effectiveLoad(accountId) {
+    const base = this.loadScore(accountId);
+    const active = this.activeCounts.get(accountId) ?? 0;
+    return base + ACTIVE_SESSION_LOAD_PENALTY * active;
+  }
+  release(accountId) {
+    const current = this.activeCounts.get(accountId);
+    if (current === undefined)
+      return;
+    this.activeCounts.set(accountId, Math.max(0, current - 1));
+  }
+  setUsage(accountId, usage) {
+    if (!this.byId.has(accountId))
+      return;
+    this.usage.set(accountId, usage);
+    if (usage) {
+      log37.debug(`Account "${accountId}" usage: ${usageLoadScore(usage)}% (load score)`);
+    }
+  }
+  markCooling(accountId, untilEpochMs) {
+    if (!this.byId.has(accountId)) {
+      log37.warn(`markCooling called for unknown account "${accountId}"`);
+      return;
+    }
+    const existing = this.coolingUntil.get(accountId) ?? 0;
+    if (untilEpochMs > existing) {
+      this.coolingUntil.set(accountId, untilEpochMs);
+      const minutes = Math.ceil((untilEpochMs - Date.now()) / 60000);
+      log37.info(`Account "${accountId}" cooling for ~${minutes}min`);
+    }
+  }
+  get(accountId) {
+    return this.byId.get(accountId);
+  }
+  status() {
+    const now = Date.now();
+    return this.accounts.map((acc) => {
+      const cooling = this.coolingUntil.get(acc.id) ?? 0;
+      const usage = this.usage.get(acc.id) ?? null;
+      return {
+        id: acc.id,
+        displayName: acc.displayName ?? acc.id,
+        activeSessions: this.activeCounts.get(acc.id) ?? 0,
+        coolingUntil: cooling > now ? cooling : null,
+        usagePercent: usage ? usageLoadScore(usage) : null
+      };
+    });
+  }
+  incrementActive(accountId) {
+    this.activeCounts.set(accountId, (this.activeCounts.get(accountId) ?? 0) + 1);
+  }
+}
+
+// src/cleanup/scheduler.ts
+init_logger();
+import { existsSync as existsSync14 } from "fs";
+import { readdir, rm as rm3 } from "fs/promises";
+import { join as join13 } from "path";
+init_worktree();
+var log38 = createLogger("cleanup");
+var DEFAULT_CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+var MAX_WORKTREE_AGE_MS = 24 * 60 * 60 * 1000;
+
+class CleanupScheduler {
   intervalMs;
-  sessionTimeoutMs;
-  sessionWarningMs;
-  getContext;
-  getSessionCount;
-  updateStickyMessage;
+  logRetentionDays;
+  threadLogsEnabled;
+  sessionStore;
+  maxWorktreeAgeMs;
+  cleanupWorktrees;
   timer = null;
   isRunning = false;
   constructor(options) {
-    this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
-    this.sessionTimeoutMs = options.sessionTimeoutMs;
-    this.sessionWarningMs = options.sessionWarningMs;
-    this.getContext = options.getContext;
-    this.getSessionCount = options.getSessionCount;
-    this.updateStickyMessage = options.updateStickyMessage;
+    this.intervalMs = options.intervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS;
+    this.logRetentionDays = options.logRetentionDays ?? 30;
+    this.threadLogsEnabled = options.threadLogsEnabled ?? true;
+    this.sessionStore = options.sessionStore;
+    this.maxWorktreeAgeMs = options.maxWorktreeAgeMs ?? MAX_WORKTREE_AGE_MS;
+    this.cleanupWorktrees = options.cleanupWorktrees ?? true;
   }
   start() {
     if (this.isRunning) {
-      log34.debug("Session monitor already running");
+      log38.debug("Cleanup scheduler already running");
       return;
     }
     this.isRunning = true;
-    log34.debug(`Session monitor started (interval: ${this.intervalMs / 1000}s)`);
+    log38.info(`Cleanup scheduler started (interval: ${Math.round(this.intervalMs / 60000)}min)`);
+    this.runCleanup().catch((err) => {
+      log38.warn(`Initial cleanup failed: ${err}`);
+    });
     this.timer = setInterval(() => {
-      this.runCheck().catch((err) => {
-        log34.error(`Error during session monitoring: ${err}`);
+      this.runCleanup().catch((err) => {
+        log38.warn(`Periodic cleanup failed: ${err}`);
       });
     }, this.intervalMs);
   }
@@ -71916,20 +72521,141 @@ class SessionMonitor {
       this.timer = null;
     }
     this.isRunning = false;
-    log34.debug("Session monitor stopped");
+    log38.debug("Cleanup scheduler stopped");
   }
-  async runCheck() {
-    await cleanupIdleSessions(this.sessionTimeoutMs, this.sessionWarningMs, this.getContext());
-    if (this.getSessionCount() > 0) {
-      await this.updateStickyMessage();
+  async runCleanup() {
+    const startTime = Date.now();
+    log38.debug("Running background cleanup...");
+    const stats = {
+      logsDeleted: 0,
+      worktreesCleaned: 0,
+      metadataCleaned: 0,
+      errors: []
+    };
+    const cleanupTasks = [
+      this.cleanupLogs().catch((err) => {
+        stats.errors.push(`Log cleanup: ${err}`);
+        return 0;
+      })
+    ];
+    if (this.cleanupWorktrees) {
+      cleanupTasks.push(this.cleanupOrphanedWorktrees().catch((err) => {
+        stats.errors.push(`Worktree cleanup: ${err}`);
+        return { cleaned: 0, metadata: 0 };
+      }));
+    }
+    const [logStats, worktreeStats = { cleaned: 0, metadata: 0 }] = await Promise.all(cleanupTasks);
+    stats.logsDeleted = logStats;
+    stats.worktreesCleaned = worktreeStats.cleaned;
+    stats.metadataCleaned = worktreeStats.metadata;
+    const elapsed = Date.now() - startTime;
+    const totalCleaned = stats.logsDeleted + stats.worktreesCleaned + stats.metadataCleaned;
+    if (totalCleaned > 0 || stats.errors.length > 0) {
+      log38.info(`Cleanup completed in ${elapsed}ms: ` + `${stats.logsDeleted} logs, ${stats.worktreesCleaned} worktrees, ${stats.metadataCleaned} metadata` + (stats.errors.length > 0 ? ` (${stats.errors.length} errors)` : ""));
+    } else {
+      log38.debug(`Cleanup completed in ${elapsed}ms (nothing to clean)`);
+    }
+    return stats;
+  }
+  async cleanupLogs() {
+    if (!this.threadLogsEnabled) {
+      return 0;
     }
+    return new Promise((resolve7) => {
+      try {
+        const deleted = cleanupOldLogs(this.logRetentionDays);
+        resolve7(deleted);
+      } catch (err) {
+        log38.warn(`Log cleanup error: ${err}`);
+        resolve7(0);
+      }
+    });
+  }
+  async cleanupOrphanedWorktrees() {
+    const worktreesDir = getWorktreesDir();
+    const result = { cleaned: 0, metadata: 0 };
+    if (!existsSync14(worktreesDir)) {
+      log38.debug("No worktrees directory exists, nothing to clean");
+      return result;
+    }
+    const persisted = this.sessionStore.load();
+    const activeWorktrees = new Set;
+    for (const session of persisted.values()) {
+      if (session.worktreeInfo?.worktreePath) {
+        activeWorktrees.add(session.worktreeInfo.worktreePath);
+      }
+    }
+    const now = Date.now();
+    try {
+      const entries = await readdir(worktreesDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory())
+          continue;
+        const worktreePath = join13(worktreesDir, entry.name);
+        if (activeWorktrees.has(worktreePath)) {
+          log38.debug(`Worktree in use by persisted session, skipping: ${entry.name}`);
+          continue;
+        }
+        const meta = await readWorktreeMetadata(worktreePath);
+        let shouldCleanup = false;
+        let cleanupReason = "";
+        if (meta) {
+          const lastActivity = new Date(meta.lastActivityAt).getTime();
+          const age = now - lastActivity;
+          if (meta.sessionId && age < this.maxWorktreeAgeMs) {
+            log38.debug(`Worktree has active session (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            continue;
+          }
+          const merged = age >= this.maxWorktreeAgeMs ? await isBranchMerged(meta.repoRoot, meta.branch).catch(() => false) : false;
+          if (merged) {
+            shouldCleanup = true;
+            cleanupReason = `branch "${meta.branch}" was merged`;
+          } else if (age >= this.maxWorktreeAgeMs) {
+            shouldCleanup = true;
+            cleanupReason = `inactive for ${Math.round(age / 3600000)}h`;
+          } else {
+            log38.debug(`Worktree recent (${Math.round(age / 60000)}min old), skipping: ${entry.name}`);
+            continue;
+          }
+        } else {
+          shouldCleanup = true;
+          cleanupReason = "no metadata";
+        }
+        if (!shouldCleanup)
+          continue;
+        log38.info(`Cleaning worktree (${cleanupReason}): ${entry.name}`);
+        try {
+          if (meta?.repoRoot) {
+            await removeWorktree(meta.repoRoot, worktreePath);
+          } else {
+            await rm3(worktreePath, { recursive: true, force: true });
+          }
+          result.cleaned++;
+          await removeWorktreeMetadata(worktreePath);
+          result.metadata++;
+        } catch (err) {
+          log38.warn(`Failed to clean orphaned worktree ${entry.name}: ${err}`);
+          try {
+            await rm3(worktreePath, { recursive: true, force: true });
+            result.cleaned++;
+            await removeWorktreeMetadata(worktreePath);
+            result.metadata++;
+          } catch (rmErr) {
+            log38.error(`Failed to force remove worktree ${entry.name}: ${rmErr}`);
+          }
+        }
+      }
+    } catch (err) {
+      log38.warn(`Failed to scan worktrees directory: ${err}`);
+    }
+    return result;
   }
 }
 // src/operations/plugin/handler.ts
 init_spawn();
 init_logger();
-var log35 = createLogger("plugin");
-var sessionLog7 = createSessionLog(log35);
+var log39 = createLogger("plugin");
+var sessionLog7 = createSessionLog(log39);
 async function buildPluginRestartCliOptions(session, ctx) {
   const account = session.claudeAccountId ? ctx.ops.getClaudeAccount(session.claudeAccountId) : undefined;
   const memoryConfig = ctx.ops.getPlatformMemoryConfig(session.platformId);
@@ -71971,7 +72697,7 @@ async function runPluginCommand(args, cwd, timeout2 = 60000) {
     });
     proc.on("error", (err) => {
       resolve7({ stdout, stderr, exitCode: 1 });
-      log35.error(`Plugin command error: ${err.message}`);
+      log39.error(`Plugin command error: ${err.message}`);
     });
   });
 }
@@ -72145,7 +72871,7 @@ class SessionRegistry {
 // src/session/reaction-router.ts
 init_emoji();
 init_logger();
-var log36 = createLogger("manager");
+var log40 = createLogger("manager");
 async function handleReaction(deps, platformId, postId, emojiName, username, action) {
   const normalizedEmoji = normalizeEmojiName(emojiName);
   if (action === "added" && isResumeEmoji(normalizedEmoji)) {
@@ -72159,7 +72885,7 @@ async function handleReaction(deps, platformId, postId, emojiName, username, act
   if (session.platformId !== platformId)
     return;
   if (!session.sessionAllowedUsers.has(username) && !session.platform.isUserAllowed(username)) {
-    log36.info(`\uD83D\uDEAB rejected reaction from unauthorized user`, {
+    log40.info(`\uD83D\uDEAB rejected reaction from unauthorized user`, {
       event: "reaction.rejected",
       platformId,
       sessionId: session.sessionId,
@@ -72195,7 +72921,7 @@ async function tryResumeFromReaction(deps, platformId, postId, username) {
     return false;
   }
   const shortId = persistedSession.threadId.substring(0, 8);
-  log36.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
+  log40.info(`\uD83D\uDD04 Resuming session ${shortId}... via emoji reaction by @${username}`);
   await resumeSession(persistedSession, deps.getContext());
   return true;
 }
@@ -72225,7 +72951,7 @@ async function dispatch(deps, session, postId, emojiName, username, action) {
     }
     if (session.lastError?.postId === postId && isBugReportEmoji(emojiName)) {
       if (session.startedBy === username || session.platform.isUserAllowed(username) || session.sessionAllowedUsers.has(username)) {
-        log36.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
+        log40.info(`\uD83D\uDC1B @${username} triggered bug report from error reaction`);
         await reportBug(session, undefined, username, deps.getContext(), session.lastError);
         return;
       }
@@ -72240,7 +72966,7 @@ async function dispatch(deps, session, postId, emojiName, username, action) {
 
 // src/session/manager.ts
 init_logger();
-var log37 = createLogger("manager");
+var log41 = createLogger("manager");
 var USAGE_PROBE_TIMEOUT_MS = 1e4;
 var USAGE_REFRESH_DEADLINE_MS = 5000;
 var USAGE_CACHE_TTL_MS = 15000;
@@ -72264,6 +72990,8 @@ class SessionManager extends EventEmitter4 {
   sessionStore;
   githubEmailsStore;
   memoryStore;
+  routinesStore;
+  routineScheduler = null;
   sessionMonitor = null;
   backgroundCleanup = null;
   isShuttingDown = false;
@@ -72271,6 +72999,7 @@ class SessionManager extends EventEmitter4 {
   customFooter;
   platformOverhead = new Map;
   platformMemory = new Map;
+  platformRoutines = new Map;
   autoUpdateManager = null;
   accountPool;
   usageRefreshInFlight = null;
@@ -72289,6 +73018,7 @@ class SessionManager extends EventEmitter4 {
     this.sessionStore = new SessionStore(sessionsPath);
     this.githubEmailsStore = new GitHubEmailsStore;
     this.memoryStore = new MemoryStore;
+    this.routinesStore = new RoutinesStore;
     this.registry = new SessionRegistry(this.sessionStore);
     this.accountPool = new AccountPool(claudeAccounts);
     this.sessionMonitor = new SessionMonitor({
@@ -72306,14 +73036,28 @@ class SessionManager extends EventEmitter4 {
       maxWorktreeAgeMs: this.limits.maxWorktreeAgeHours * 60 * 60 * 1000,
       cleanupWorktrees: this.limits.cleanupWorktrees
     });
+    this.routineScheduler = new RoutineScheduler({
+      store: this.routinesStore,
+      listPlatformIds: () => Array.from(this.platforms.keys()),
+      isRoutinesEnabled: (pid) => this.platformRoutines.get(pid) ?? true,
+      fireRoutine: (pid, routine) => fireRoutine(routine, pid, this.getContext()),
+      notifyDisabled: async (pid, routine, reason) => {
+        const platform = this.platforms.get(pid);
+        if (!platform)
+          return;
+        const formatter = platform.getFormatter();
+        await platform.createPost(`\uD83D\uDD58 ${formatter.formatBold(`Routine "${routine.name}" disabled`)} — ${reason}. ` + `Re-enable with ${formatter.formatCode("!routines resume <n>")} once resolved.`).catch(() => {});
+      }
+    });
   }
-  addPlatform(platformId, client, overhead, memory) {
+  addPlatform(platformId, client, overhead, memory, routinesEnabled) {
     this.platforms.set(platformId, client);
     this.platformOverhead.set(platformId, {
       sessionHeader: overhead?.sessionHeader ?? DEFAULT_OVERHEAD_VISIBILITY,
       stickyMessage: overhead?.stickyMessage ?? DEFAULT_OVERHEAD_VISIBILITY
     });
     this.platformMemory.set(platformId, memory ?? DEFAULT_MEMORY_CONFIG);
+    this.platformRoutines.set(platformId, routinesEnabled ?? true);
     client.on("message", (post2, user) => this.handleMessage(platformId, post2, user));
     client.on("reaction", (reaction, user) => {
       if (user) {
@@ -72332,12 +73076,13 @@ class SessionManager extends EventEmitter4 {
       markNeedsBump(platformId);
       this.updateStickyMessage();
     });
-    log37.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
+    log41.info(`\uD83D\uDCE1 Platform "${platformId}" registered`);
   }
   removePlatform(platformId) {
     this.platforms.delete(platformId);
     this.platformOverhead.delete(platformId);
     this.platformMemory.delete(platformId);
+    this.platformRoutines.delete(platformId);
     clearHiddenCleanupTracking(platformId);
   }
   setAutoUpdateManager(manager) {
@@ -72351,7 +73096,7 @@ class SessionManager extends EventEmitter4 {
     if (users) {
       users.add(sessionId);
     }
-    log37.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
+    log41.debug(`Registered session ${sessionId.substring(0, 20)} as worktree user for ${worktreePath}`);
   }
   unregisterWorktreeUser(worktreePath, sessionId) {
     const users = this.worktreeUsers.get(worktreePath);
@@ -72377,6 +73122,7 @@ class SessionManager extends EventEmitter4 {
       userAttribution: this.userAttribution,
       debug: this.debug,
       maxSessions: this.limits.maxSessions,
+      maxRoutines: this.limits.maxRoutines,
       threadLogsEnabled: this.threadLogsEnabled,
       threadLogsRetentionDays: this.threadLogsRetentionDays,
       permissionTimeoutMs: this.limits.permissionTimeoutSeconds * 1000,
@@ -72389,6 +73135,7 @@ class SessionManager extends EventEmitter4 {
       sessionStore: this.sessionStore,
       githubEmailsStore: this.githubEmailsStore,
       memoryStore: this.memoryStore,
+      routinesStore: this.routinesStore,
       isShuttingDown: this.isShuttingDown
     };
     const ops = {
@@ -72434,7 +73181,9 @@ class SessionManager extends EventEmitter4 {
         sessionHeader: DEFAULT_OVERHEAD_VISIBILITY,
         stickyMessage: DEFAULT_OVERHEAD_VISIBILITY
       },
-      getPlatformMemoryConfig: (pid) => this.platformMemory.get(pid) ?? DEFAULT_MEMORY_CONFIG
+      getPlatformMemoryConfig: (pid) => this.platformMemory.get(pid) ?? DEFAULT_MEMORY_CONFIG,
+      isRoutinesEnabled: (pid) => this.platformRoutines.get(pid) ?? true,
+      fireRoutineNow: (pid, routine) => this.fireRoutineNowImpl(pid, routine)
     };
     return createSessionContext(config, state, ops);
   }
@@ -72553,7 +73302,7 @@ class SessionManager extends EventEmitter4 {
     try {
       this.persistSessionUnsafe(session);
     } catch (err) {
-      log37.error(`Failed to persist session ${session.sessionId}: ${err}`);
+      log41.error(`Failed to persist session ${session.sessionId}: ${err}`);
     }
   }
   persistSessionUnsafe(session) {
@@ -72669,11 +73418,11 @@ class SessionManager extends EventEmitter4 {
       }
     }
     if (sessionsToKill.length === 0) {
-      log37.info(`No active sessions to pause for platform ${platformId}`);
+      log41.info(`No active sessions to pause for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log37.info(`⏸️ Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
+    log41.info(`⏸️ Pausing ${sessionsToKill.length} session(s) for platform ${platformId}`);
     for (const session of sessionsToKill) {
       try {
         const fmt = session.platform.getFormatter();
@@ -72689,9 +73438,9 @@ class SessionManager extends EventEmitter4 {
         session.claude.kill();
         this.registry.unregister(session.sessionId);
         this.emitSessionRemove(session.sessionId);
-        log37.info(`⏸️ Paused session ${session.threadId.substring(0, 8)}`);
+        log41.info(`⏸️ Paused session ${session.threadId.substring(0, 8)}`);
       } catch (err) {
-        log37.warn(`Failed to pause session ${session.threadId}: ${err}`);
+        log41.warn(`Failed to pause session ${session.threadId}: ${err}`);
       }
     }
     for (const session of sessionsToKill) {
@@ -72712,17 +73461,17 @@ class SessionManager extends EventEmitter4 {
       sessionsToResume.push(state);
     }
     if (sessionsToResume.length === 0) {
-      log37.info(`No paused sessions to resume for platform ${platformId}`);
+      log41.info(`No paused sessions to resume for platform ${platformId}`);
       await this.updateStickyMessage();
       return;
     }
-    log37.info(`▶️ Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
+    log41.info(`▶️ Resuming ${sessionsToResume.length} paused session(s) for platform ${platformId}`);
     for (const state of sessionsToResume) {
       try {
         await resumeSession(state, this.getContext());
-        log37.info(`▶️ Resumed session ${state.threadId.substring(0, 8)}`);
+        log41.info(`▶️ Resumed session ${state.threadId.substring(0, 8)}`);
       } catch (err) {
-        log37.warn(`Failed to resume session ${state.threadId}: ${err}`);
+        log41.warn(`Failed to resume session ${state.threadId}: ${err}`);
       }
     }
     await this.updateStickyMessage();
@@ -72757,17 +73506,18 @@ class SessionManager extends EventEmitter4 {
     initialize(this.sessionStore);
     this.sessionMonitor?.start();
     this.backgroundCleanup?.start();
+    this.routineScheduler?.start();
     const sessionTimeoutMs = this.limits.sessionTimeoutMinutes * 60 * 1000;
     const staleIds = this.sessionStore.cleanStale(sessionTimeoutMs * 2);
     if (staleIds.length > 0) {
-      log37.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
+      log41.info(`\uD83E\uDDF9 Soft-deleted ${staleIds.length} stale session(s) (kept for history)`);
     }
     const removedCount = this.sessionStore.cleanHistory();
     if (removedCount > 0) {
-      log37.info(`\uD83D\uDDD1️ Permanently removed ${removedCount} old session(s) from history`);
+      log41.info(`\uD83D\uDDD1️ Permanently removed ${removedCount} old session(s) from history`);
     }
     const persisted = this.sessionStore.load();
-    log37.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
+    log41.info(`\uD83D\uDCC2 Loaded ${persisted.size} session(s) from persistence`);
     const excludePostIdsByPlatform = new Map;
     for (const session of persisted.values()) {
       const platformId = session.platformId;
@@ -72787,10 +73537,10 @@ class SessionManager extends EventEmitter4 {
       const excludePostIds = excludePostIdsByPlatform.get(platform.platformId);
       platform.getBotUser().then((botUser) => {
         cleanupOldStickyMessages(platform, botUser.id, true, excludePostIds).catch((err) => {
-          log37.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
+          log41.warn(`Failed to cleanup old sticky messages for ${platform.platformId}: ${err}`);
         });
       }).catch((err) => {
-        log37.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
+        log41.warn(`Failed to get bot user for cleanup on ${platform.platformId}: ${err}`);
       });
     }
     if (persisted.size > 0) {
@@ -72804,10 +73554,10 @@ class SessionManager extends EventEmitter4 {
         }
       }
       if (pausedToSkip.length > 0) {
-        log37.info(`⏸️ ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
+        log41.info(`⏸️ ${pausedToSkip.length} session(s) remain paused (waiting for user message)`);
       }
       if (activeToResume.length > 0) {
-        log37.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
+        log41.info(`\uD83D\uDD04 Attempting to resume ${activeToResume.length} active session(s)...`);
         for (const state of activeToResume) {
           await resumeSession(state, this.getContext());
         }
@@ -72926,6 +73676,23 @@ class SessionManager extends EventEmitter4 {
       return;
     await forgetMemory(session, selector, username, this.getContext());
   }
+  async createRoutine(threadId, request, username) {
+    const session = this.findSessionByThreadId(threadId);
+    if (!session)
+      return;
+    await createRoutine(session, request, username, this.getContext());
+  }
+  async manageRoutines(threadId, args, username) {
+    const session = this.findSessionByThreadId(threadId);
+    if (!session)
+      return;
+    await manageRoutines(session, args, username, this.getContext());
+  }
+  async fireRoutineNowImpl(platformId, routine) {
+    if (!this.routineScheduler)
+      return "skipped";
+    return this.routineScheduler.fire(platformId, routine, new Date, false);
+  }
   async setRespondOnlyWhenMentioned(threadId, username, arg) {
     const session = this.findSessionByThreadId(threadId);
     if (!session)
@@ -73268,7 +74035,7 @@ Mention me to start a session in this worktree.`, threadId);
         const message = messageBuilder(formatter);
         await post(session, "info", message);
       } catch (err) {
-        log37.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
+        log41.warn(`Failed to broadcast to session ${session.threadId}: ${err}`);
       }
     }
   }
@@ -73287,7 +74054,7 @@ Mention me to start a session in this worktree.`, threadId);
         session.messageManager?.setPendingUpdatePrompt({ postId: post2.id });
         this.registerPost(post2.id, session.threadId);
       } catch (err) {
-        log37.warn(`Failed to post ask message to ${threadId}: ${err}`);
+        log41.warn(`Failed to post ask message to ${threadId}: ${err}`);
       }
     }
   }
@@ -73295,6 +74062,7 @@ Mention me to start a session in this worktree.`, threadId);
     this.isShuttingDown = true;
     this.sessionMonitor?.stop();
     this.backgroundCleanup?.stop();
+    this.routineScheduler?.stop();
     if (message) {
       for (const session of this.registry.getAll()) {
         try {
@@ -80881,29 +81649,29 @@ function SessionLog({ logs, maxLines = 20 }) {
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     flexDirection: "column",
     flexShrink: 0,
-    children: displayLogs.map((log38) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
+    children: displayLogs.map((log42) => /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
       flexShrink: 0,
       children: [
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log38.level),
+          color: getColorForLevel(log42.level),
           dimColor: true,
           wrap: "truncate",
           children: [
             "[",
-            padComponent(log38.component),
+            padComponent(log42.component),
             "]"
           ]
         }, undefined, true, undefined, this),
         /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
-          color: getColorForLevel(log38.level),
+          color: getColorForLevel(log42.level),
           wrap: "truncate",
           children: [
             " ",
-            log38.message
+            log42.message
           ]
         }, undefined, true, undefined, this)
       ]
-    }, log38.id, true, undefined, this))
+    }, log42.id, true, undefined, this))
   }, undefined, false, undefined, this);
 }
 // src/ui/components/Footer.tsx
@@ -81427,7 +82195,7 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
   const scrollRef = import_react59.default.useRef(null);
   const { stdout } = use_stdout_default();
   const isDebug = process.env.DEBUG === "1";
-  const displayLogs = logs.filter((log38) => isDebug || log38.level !== "debug");
+  const displayLogs = logs.filter((log42) => isDebug || log42.level !== "debug");
   const visibleLogs = displayLogs.slice(-Math.max(maxLines * 3, 100));
   import_react59.default.useEffect(() => {
     const handleResize = () => scrollRef.current?.remeasure();
@@ -81467,25 +82235,25 @@ function LogPanel({ logs, maxLines = 10, focused = false }) {
     overflow: "hidden",
     children: /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(ScrollView, {
       ref: scrollRef,
-      children: visibleLogs.map((log38) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
+      children: visibleLogs.map((log42) => /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
         children: [
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
             dimColor: true,
             children: [
               "[",
-              padComponent2(log38.component),
+              padComponent2(log42.component),
               "]"
             ]
           }, undefined, true, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Text, {
-            color: getLevelColor(log38.level),
+            color: getLevelColor(log42.level),
             children: [
               " ",
-              log38.message
+              log42.message
             ]
           }, undefined, true, undefined, this)
         ]
-      }, log38.id, true, undefined, this))
+      }, log42.id, true, undefined, this))
     }, undefined, false, undefined, this)
   }, undefined, false, undefined, this);
 }
@@ -82002,10 +82770,10 @@ function useAppState(initialConfig) {
     });
   }, []);
   const getLogsForSession = import_react60.useCallback((sessionId) => {
-    return state.logs.filter((log38) => log38.sessionId === sessionId);
+    return state.logs.filter((log42) => log42.sessionId === sessionId);
   }, [state.logs]);
   const getGlobalLogs = import_react60.useCallback(() => {
-    return state.logs.filter((log38) => !log38.sessionId);
+    return state.logs.filter((log42) => !log42.sessionId);
   }, [state.logs]);
   const togglePlatformEnabled = import_react60.useCallback((platformId) => {
     let newEnabled = false;
@@ -83020,7 +83788,7 @@ import { EventEmitter as EventEmitter9 } from "events";
 // src/auto-update/checker.ts
 init_logger();
 import { EventEmitter as EventEmitter7 } from "events";
-var log38 = createLogger("checker");
+var log42 = createLogger("checker");
 var PACKAGE_NAME = "claude-threads";
 function compareVersions(a, b) {
   const partsA = a.replace(/^v/, "").split(".").map(Number);
@@ -83043,13 +83811,13 @@ async function fetchLatestVersion() {
       }
     });
     if (!response.ok) {
-      log38.warn(`Failed to fetch latest version: HTTP ${response.status}`);
+      log42.warn(`Failed to fetch latest version: HTTP ${response.status}`);
       return null;
     }
     const data = await response.json();
     return data.version ?? null;
   } catch (err) {
-    log38.warn(`Failed to fetch latest version: ${err}`);
+    log42.warn(`Failed to fetch latest version: ${err}`);
     return null;
   }
 }
@@ -83066,38 +83834,38 @@ class UpdateChecker extends EventEmitter7 {
   }
   start() {
     if (!this.config.enabled) {
-      log38.debug("Auto-update disabled, not starting checker");
+      log42.debug("Auto-update disabled, not starting checker");
       return;
     }
     setTimeout(() => {
       this.check().catch((err) => {
-        log38.warn(`Initial update check failed: ${err}`);
+        log42.warn(`Initial update check failed: ${err}`);
       });
     }, 5000);
     const intervalMs = this.config.checkIntervalMinutes * 60 * 1000;
     this.checkInterval = setInterval(() => {
       this.check().catch((err) => {
-        log38.warn(`Periodic update check failed: ${err}`);
+        log42.warn(`Periodic update check failed: ${err}`);
       });
     }, intervalMs);
-    log38.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
+    log42.info(`\uD83D\uDD04 Update checker started (every ${this.config.checkIntervalMinutes} minutes)`);
   }
   stop() {
     if (this.checkInterval) {
       clearInterval(this.checkInterval);
       this.checkInterval = null;
     }
-    log38.debug("Update checker stopped");
+    log42.debug("Update checker stopped");
   }
   async check() {
     if (this.isChecking) {
-      log38.debug("Check already in progress, skipping");
+      log42.debug("Check already in progress, skipping");
       return this.lastUpdateInfo;
     }
     this.isChecking = true;
     this.emit("check:start");
     try {
-      log38.debug("Checking for updates...");
+      log42.debug("Checking for updates...");
       const latestVersion2 = await fetchLatestVersion();
       if (!latestVersion2) {
         this.emit("check:complete", false);
@@ -83114,18 +83882,18 @@ class UpdateChecker extends EventEmitter7 {
           detectedAt: new Date
         };
         if (!this.lastUpdateInfo || this.lastUpdateInfo.latestVersion !== latestVersion2) {
-          log38.info(`\uD83C\uDD95 Update available: v${currentVersion} → v${latestVersion2}`);
+          log42.info(`\uD83C\uDD95 Update available: v${currentVersion} → v${latestVersion2}`);
           this.lastUpdateInfo = updateInfo;
           this.emit("update", updateInfo);
         }
         this.emit("check:complete", true);
         return updateInfo;
       }
-      log38.debug(`Up to date (v${currentVersion})`);
+      log42.debug(`Up to date (v${currentVersion})`);
       this.emit("check:complete", false);
       return null;
     } catch (err) {
-      log38.warn(`Update check failed: ${err}`);
+      log42.warn(`Update check failed: ${err}`);
       this.emit("check:error", err);
       return null;
     } finally {
@@ -83196,7 +83964,7 @@ function isInScheduledWindow(window2) {
 }
 
 // src/auto-update/scheduler.ts
-var log39 = createLogger("scheduler");
+var log43 = createLogger("scheduler");
 
 class UpdateScheduler extends EventEmitter8 {
   config;
@@ -83220,7 +83988,7 @@ class UpdateScheduler extends EventEmitter8 {
   scheduleUpdate(updateInfo) {
     this.pendingUpdate = updateInfo;
     if (this.config.autoRestartMode === "immediate") {
-      log39.info("Immediate mode: triggering update now");
+      log43.info("Immediate mode: triggering update now");
       this.emit("ready", updateInfo);
       return;
     }
@@ -83233,19 +84001,19 @@ class UpdateScheduler extends EventEmitter8 {
     this.scheduledRestartAt = null;
     this.askApprovals.clear();
     this.askStartTime = null;
-    log39.debug("Update schedule cancelled");
+    log43.debug("Update schedule cancelled");
   }
   deferUpdate(minutes) {
     const deferUntil = new Date(Date.now() + minutes * 60 * 1000);
     this.scheduledRestartAt = null;
     this.idleStartTime = null;
     this.emit("deferred", deferUntil);
-    log39.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
+    log43.info(`Update deferred until ${deferUntil.toLocaleTimeString()}`);
     return deferUntil;
   }
   recordAskResponse(threadId, approved) {
     this.askApprovals.set(threadId, approved);
-    log39.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
+    log43.debug(`Thread ${threadId.substring(0, 8)} ${approved ? "approved" : "denied"} update`);
     this.checkAskCondition();
   }
   getScheduledRestartAt() {
@@ -83266,7 +84034,7 @@ class UpdateScheduler extends EventEmitter8 {
       return;
     this.checkCondition();
     this.checkTimer = setInterval(() => this.checkCondition(), 1e4);
-    log39.debug(`Started checking for ${this.config.autoRestartMode} condition`);
+    log43.debug(`Started checking for ${this.config.autoRestartMode} condition`);
   }
   stopChecking() {
     if (this.checkTimer) {
@@ -83297,17 +84065,17 @@ class UpdateScheduler extends EventEmitter8 {
     if (activity.activeSessionCount === 0) {
       if (!this.idleStartTime) {
         this.idleStartTime = new Date;
-        log39.debug("No active sessions, starting idle timer");
+        log43.debug("No active sessions, starting idle timer");
       }
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log39.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
+        log43.info(`Idle for ${this.config.idleTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else {
       if (this.idleStartTime) {
-        log39.debug("Sessions became active, resetting idle timer");
+        log43.debug("Sessions became active, resetting idle timer");
         this.idleStartTime = null;
       }
     }
@@ -83318,7 +84086,7 @@ class UpdateScheduler extends EventEmitter8 {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log39.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
+        log43.info(`Sessions quiet for ${this.config.quietTimeoutMinutes} minutes, triggering update`);
         this.triggerCountdown();
       }
     } else if (activity.activeSessionCount === 0) {
@@ -83328,7 +84096,7 @@ class UpdateScheduler extends EventEmitter8 {
       const idleMs = Date.now() - this.idleStartTime.getTime();
       const requiredMs = this.config.quietTimeoutMinutes * 60 * 1000;
       if (idleMs >= requiredMs) {
-        log39.info("No sessions and quiet timeout reached, triggering update");
+        log43.info("No sessions and quiet timeout reached, triggering update");
         this.triggerCountdown();
       }
     }
@@ -83339,13 +84107,13 @@ class UpdateScheduler extends EventEmitter8 {
     }
     const activity = this.getSessionActivity();
     if (activity.activeSessionCount === 0) {
-      log39.info("Within scheduled window and no active sessions, triggering update");
+      log43.info("Within scheduled window and no active sessions, triggering update");
       this.triggerCountdown();
     } else if (activity.lastActivityAt) {
       const quietMs = Date.now() - activity.lastActivityAt.getTime();
       const requiredMs = this.config.idleTimeoutMinutes * 60 * 1000;
       if (quietMs >= requiredMs && !activity.anySessionBusy) {
-        log39.info("Within scheduled window and sessions quiet, triggering update");
+        log43.info("Within scheduled window and sessions quiet, triggering update");
         this.triggerCountdown();
       }
     }
@@ -83353,14 +84121,14 @@ class UpdateScheduler extends EventEmitter8 {
   checkAskCondition() {
     const threadIds = this.getActiveThreadIds();
     if (threadIds.length === 0) {
-      log39.info("No active threads, proceeding with update");
+      log43.info("No active threads, proceeding with update");
       this.triggerCountdown();
       return;
     }
     if (!this.askStartTime && this.pendingUpdate) {
       this.askStartTime = new Date;
       this.postAskMessage(threadIds, this.pendingUpdate.latestVersion).catch((err) => {
-        log39.warn(`Failed to post ask message: ${err}`);
+        log43.warn(`Failed to post ask message: ${err}`);
       });
       return;
     }
@@ -83373,12 +84141,12 @@ class UpdateScheduler extends EventEmitter8 {
         denials++;
     }
     if (approvals > threadIds.length / 2) {
-      log39.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
+      log43.info(`Majority approved (${approvals}/${threadIds.length}), triggering update`);
       this.triggerCountdown();
       return;
     }
     if (denials > threadIds.length / 2) {
-      log39.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
+      log43.info(`Majority denied (${denials}/${threadIds.length}), deferring update`);
       this.deferUpdate(60);
       return;
     }
@@ -83386,7 +84154,7 @@ class UpdateScheduler extends EventEmitter8 {
       const elapsedMs = Date.now() - this.askStartTime.getTime();
       const timeoutMs = this.config.askTimeoutMinutes * 60 * 1000;
       if (elapsedMs >= timeoutMs) {
-        log39.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
+        log43.info(`Ask timeout reached (${this.config.askTimeoutMinutes} min), triggering update`);
         this.triggerCountdown();
       }
     }
@@ -83406,7 +84174,7 @@ class UpdateScheduler extends EventEmitter8 {
         this.emit("ready", this.pendingUpdate);
       }
     }, 1000);
-    log39.info("Update countdown started (60 seconds)");
+    log43.info("Update countdown started (60 seconds)");
   }
   stopCountdown() {
     if (this.countdownTimer) {
@@ -83419,27 +84187,27 @@ class UpdateScheduler extends EventEmitter8 {
 // src/auto-update/installer.ts
 init_logger();
 import { spawn as spawn4, spawnSync } from "child_process";
-import { existsSync as existsSync15, readFileSync as readFileSync11, writeFileSync as writeFileSync8, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync9, mkdirSync as mkdirSync7 } from "fs";
 import { dirname as dirname9, resolve as resolve7 } from "path";
-import { homedir as homedir7 } from "os";
-var log40 = createLogger("installer");
+import { homedir as homedir8 } from "os";
+var log44 = createLogger("installer");
 function detectPackageManager() {
   const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
   const originalInstaller = detectOriginalInstaller();
   if (originalInstaller) {
-    log40.debug(`Detected original installer: ${originalInstaller}`);
+    log44.debug(`Detected original installer: ${originalInstaller}`);
     if (originalInstaller === "bun") {
       const bunCheck2 = spawnSync("bun", ["--version"], { stdio: "ignore" });
       if (bunCheck2.status === 0) {
         return { cmd: "bun", isBun: true };
       }
-      log40.warn("Originally installed with bun, but bun not found. Falling back to npm.");
+      log44.warn("Originally installed with bun, but bun not found. Falling back to npm.");
     } else {
       const npmCheck2 = spawnSync(npmCmd, ["--version"], { stdio: "ignore" });
       if (npmCheck2.status === 0) {
         return { cmd: npmCmd, isBun: false };
       }
-      log40.warn("Originally installed with npm, but npm not found. Falling back to bun.");
+      log44.warn("Originally installed with npm, but npm not found. Falling back to bun.");
     }
   }
   const bunCheck = spawnSync("bun", ["--version"], { stdio: "ignore" });
@@ -83461,7 +84229,7 @@ function normalizePath(p) {
 function detectOriginalInstaller() {
   try {
     const scriptPath = normalizePath(process.argv[1] || "");
-    const bunGlobalDir = normalizePath(process.env.BUN_INSTALL || resolve7(homedir7(), ".bun"));
+    const bunGlobalDir = normalizePath(process.env.BUN_INSTALL || resolve7(homedir8(), ".bun"));
     if (scriptPath.startsWith(bunGlobalDir)) {
       return "bun";
     }
@@ -83481,38 +84249,38 @@ function detectOriginalInstaller() {
     return null;
   }
 }
-var STATE_PATH = resolve7(homedir7(), ".config", "claude-threads", UPDATE_STATE_FILENAME);
+var STATE_PATH = resolve7(homedir8(), ".config", "claude-threads", UPDATE_STATE_FILENAME);
 var PACKAGE_NAME2 = "claude-threads";
 function loadUpdateState() {
   try {
-    if (existsSync15(STATE_PATH)) {
-      const content = readFileSync11(STATE_PATH, "utf-8");
+    if (existsSync16(STATE_PATH)) {
+      const content = readFileSync12(STATE_PATH, "utf-8");
       return JSON.parse(content);
     }
   } catch (err) {
-    log40.warn(`Failed to load update state: ${err}`);
+    log44.warn(`Failed to load update state: ${err}`);
   }
   return {};
 }
 function saveUpdateState(state) {
   try {
     const dir = dirname9(STATE_PATH);
-    if (!existsSync15(dir)) {
-      mkdirSync6(dir, { recursive: true });
+    if (!existsSync16(dir)) {
+      mkdirSync7(dir, { recursive: true });
     }
-    writeFileSync8(STATE_PATH, JSON.stringify(state, null, 2), "utf-8");
-    log40.debug("Update state saved");
+    writeFileSync9(STATE_PATH, JSON.stringify(state, null, 2), "utf-8");
+    log44.debug("Update state saved");
   } catch (err) {
-    log40.warn(`Failed to save update state: ${err}`);
+    log44.warn(`Failed to save update state: ${err}`);
   }
 }
 function clearUpdateState() {
   try {
-    if (existsSync15(STATE_PATH)) {
-      writeFileSync8(STATE_PATH, "{}", "utf-8");
+    if (existsSync16(STATE_PATH)) {
+      writeFileSync9(STATE_PATH, "{}", "utf-8");
     }
   } catch (err) {
-    log40.warn(`Failed to clear update state: ${err}`);
+    log44.warn(`Failed to clear update state: ${err}`);
   }
 }
 function checkJustUpdated() {
@@ -83544,11 +84312,11 @@ function clearRuntimeSettings() {
   }
 }
 async function installVersion(version) {
-  log40.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
+  log44.info(`\uD83D\uDCE6 Installing ${PACKAGE_NAME2}@${version}...`);
   const pm = detectPackageManager();
   if (!pm) {
     const error = "Neither bun nor npm found in PATH. Cannot install update.";
-    log40.error(`❌ ${error}`);
+    log44.error(`❌ ${error}`);
     return { success: false, error };
   }
   saveUpdateState({
@@ -83560,7 +84328,7 @@ async function installVersion(version) {
   return new Promise((resolve8) => {
     const { cmd, isBun: isBun3 } = pm;
     const args = ["install", "-g", `${PACKAGE_NAME2}@${version}`];
-    log40.debug(`Using ${isBun3 ? "bun" : "npm"} for installation`);
+    log44.debug(`Using ${isBun3 ? "bun" : "npm"} for installation`);
     const child = spawn4(cmd, args, {
       stdio: ["ignore", "pipe", "pipe"],
       env: {
@@ -83578,7 +84346,7 @@ async function installVersion(version) {
     });
     child.on("close", (code) => {
       if (code === 0) {
-        log40.info(`✅ Successfully installed ${PACKAGE_NAME2}@${version}`);
+        log44.info(`✅ Successfully installed ${PACKAGE_NAME2}@${version}`);
         saveUpdateState({
           previousVersion: VERSION,
           targetVersion: version,
@@ -83588,20 +84356,20 @@ async function installVersion(version) {
         resolve8({ success: true });
       } else {
         const errorMsg = stderr || stdout || `Exit code: ${code}`;
-        log40.error(`❌ Installation failed: ${errorMsg}`);
+        log44.error(`❌ Installation failed: ${errorMsg}`);
         clearUpdateState();
         resolve8({ success: false, error: errorMsg });
       }
     });
     child.on("error", (err) => {
-      log40.error(`❌ Failed to spawn npm: ${err}`);
+      log44.error(`❌ Failed to spawn npm: ${err}`);
       clearUpdateState();
       resolve8({ success: false, error: err.message });
     });
     setTimeout(() => {
       if (child.exitCode === null) {
         child.kill();
-        log40.error("❌ Installation timed out");
+        log44.error("❌ Installation timed out");
         clearUpdateState();
         resolve8({ success: false, error: "Installation timed out" });
       }
@@ -83645,9 +84413,9 @@ class UpdateInstaller {
 // src/auto-update/respawn.ts
 init_logger();
 import { spawn as spawn5 } from "child_process";
-import { existsSync as existsSync16, statSync as statSync4 } from "fs";
-import { delimiter, join as join13 } from "path";
-var log41 = createLogger("respawn");
+import { existsSync as existsSync17, statSync as statSync4 } from "fs";
+import { delimiter, join as join14 } from "path";
+var log45 = createLogger("respawn");
 function decideRespawn(env5 = process.env, isTTY = !!process.stdout.isTTY) {
   if (env5.CLAUDE_THREADS_BIN) {
     return { kind: "exit-for-supervisor", supervisor: "claude-threads-daemon" };
@@ -83666,22 +84434,22 @@ function decideRespawn(env5 = process.env, isTTY = !!process.stdout.isTTY) {
   }
   return { kind: "self-respawn" };
 }
-function resolveClaudeThreadsBin(_env = process.env, _existsSync = existsSync16, _isFileExecutable = isFileExecutable) {
+function resolveClaudeThreadsBin(_env = process.env, _existsSync = existsSync17, _isFileExecutable = isFileExecutable) {
   const isWin2 = process.platform === "win32";
   const names = isWin2 ? ["claude-threads.cmd", "claude-threads.exe", "claude-threads.bat"] : ["claude-threads"];
   const path10 = _env.PATH || _env.Path || "";
   const dirs = path10.split(delimiter).filter(Boolean);
   const home = _env.HOME || _env.USERPROFILE;
-  const bunRoot = _env.BUN_INSTALL || (home ? join13(home, ".bun") : null);
+  const bunRoot = _env.BUN_INSTALL || (home ? join14(home, ".bun") : null);
   if (bunRoot) {
-    const bunBin = join13(bunRoot, "bin");
+    const bunBin = join14(bunRoot, "bin");
     if (!dirs.includes(bunBin)) {
       dirs.push(bunBin);
     }
   }
   for (const dir of dirs) {
     for (const name of names) {
-      const candidate = join13(dir, name);
+      const candidate = join14(dir, name);
       if (_existsSync(candidate) && _isFileExecutable(candidate)) {
         return candidate;
       }
@@ -83703,7 +84471,7 @@ function isFileExecutable(path10) {
 }
 function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeThreadsBin()) {
   if (!binPath) {
-    log41.error("Could not resolve claude-threads on PATH; self-respawn aborted");
+    log45.error("Could not resolve claude-threads on PATH; self-respawn aborted");
     return false;
   }
   if (process.stdin.isTTY && typeof process.stdin.setRawMode === "function") {
@@ -83724,23 +84492,23 @@ function spawnReplacement(argv = process.argv.slice(2), binPath = resolveClaudeT
       shell: useShell
     });
   } catch (err) {
-    log41.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
+    log45.error(`spawn() threw: ${err instanceof Error ? err.message : String(err)}`);
     return false;
   }
   child.once("error", (err) => {
-    log41.error(`Replacement process error: ${err.message}`);
+    log45.error(`Replacement process error: ${err.message}`);
   });
   if (child.pid === undefined) {
-    log41.error("Spawn returned no pid (binary likely not executable)");
+    log45.error("Spawn returned no pid (binary likely not executable)");
     return false;
   }
   child.unref();
-  log41.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
+  log45.info(`Spawned replacement pid=${child.pid} from ${binPath}`);
   return true;
 }
 
 // src/auto-update/manager.ts
-var log42 = createLogger("updater");
+var log46 = createLogger("updater");
 
 class AutoUpdateManager extends EventEmitter9 {
   config;
@@ -83763,23 +84531,23 @@ class AutoUpdateManager extends EventEmitter9 {
   }
   start() {
     if (!this.config.enabled) {
-      log42.info("Auto-update is disabled");
+      log46.info("Auto-update is disabled");
       return;
     }
     const updateResult = this.installer.checkJustUpdated();
     if (updateResult) {
-      log42.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
+      log46.info(`\uD83C\uDF89 Updated from v${updateResult.previousVersion} to v${updateResult.currentVersion}`);
       this.callbacks.broadcastUpdate((fmt) => `\uD83C\uDF89 ${fmt.formatBold("Bot updated")} from v${updateResult.previousVersion} to v${updateResult.currentVersion}`).catch((err) => {
-        log42.warn(`Failed to broadcast update notification: ${err}`);
+        log46.warn(`Failed to broadcast update notification: ${err}`);
       });
     }
     this.checker.start();
-    log42.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
+    log46.info(`\uD83D\uDD04 Auto-update manager started (mode: ${this.config.autoRestartMode})`);
   }
   stop() {
     this.checker.stop();
     this.scheduler.stop();
-    log42.debug("Auto-update manager stopped");
+    log46.debug("Auto-update manager stopped");
   }
   getState() {
     return { ...this.state };
@@ -83793,10 +84561,10 @@ class AutoUpdateManager extends EventEmitter9 {
   async forceUpdate() {
     const updateInfo = this.state.updateInfo || await this.checker.check();
     if (!updateInfo) {
-      log42.info("No update available");
+      log46.info("No update available");
       return;
     }
-    log42.info("Forcing immediate update");
+    log46.info("Forcing immediate update");
     await this.performUpdate(updateInfo);
   }
   deferUpdate(minutes = 60) {
@@ -83862,11 +84630,11 @@ class AutoUpdateManager extends EventEmitter9 {
         await this.callbacks.prepareForRestart();
       } catch (err) {
         const reason = err instanceof Error ? err.message : String(err);
-        log42.error(`prepareForRestart failed: ${reason}`);
+        log46.error(`prepareForRestart failed: ${reason}`);
         await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Restart aborted")}: shutdown sequence failed (${reason}). Sessions may be in an inconsistent state; please run ${fmt.formatCode("claude-threads")} manually.`).catch(() => {});
         process.exit(1);
       }
-      log42.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
+      log46.info(`\uD83D\uDD04 Restarting for update to v${updateInfo.latestVersion}`);
       process.stdout.write("\x1B[2J\x1B[H");
       process.stdout.write("\x1B[?25h");
       if (decision.kind === "self-respawn") {
@@ -83875,14 +84643,14 @@ class AutoUpdateManager extends EventEmitter9 {
           if (ok) {
             process.exit(0);
           }
-          log42.error("Self-respawn launch failed after binary resolution succeeded");
+          log46.error("Self-respawn launch failed after binary resolution succeeded");
           await this.callbacks.broadcastUpdate((fmt) => `⚠️ ${fmt.formatBold("Auto-restart failed")} after install: please run ${fmt.formatCode("claude-threads")} to bring the bot back. Sessions are persisted and will resume.`).catch(() => {});
         } else {
-          log42.error("claude-threads not found on PATH; manual restart required");
+          log46.error("claude-threads not found on PATH; manual restart required");
         }
         process.exit(0);
       }
-      log42.debug(`Restart handled by supervisor: ${decision.supervisor}`);
+      log46.debug(`Restart handled by supervisor: ${decision.supervisor}`);
       process.exit(RESTART_EXIT_CODE);
     } else {
       const errorMsg = result.error ?? "Unknown error";
@@ -84266,7 +85034,7 @@ async function startWithoutDaemon() {
     session.addPlatform(platformConfig.id, client, {
       sessionHeader: resolveOverheadVisibility(platformConfig.sessionHeader, `platforms[${platformConfig.id}].sessionHeader`),
       stickyMessage: resolveOverheadVisibility(platformConfig.stickyMessage, `platforms[${platformConfig.id}].stickyMessage`)
-    }, resolveMemoryConfig(platformConfig.memory, `platforms[${platformConfig.id}].memory`));
+    }, resolveMemoryConfig(platformConfig.memory, `platforms[${platformConfig.id}].memory`), resolveRoutinesEnabled(platformConfig.routines, `platforms[${platformConfig.id}].routines`));
     wirePlatformEvents(platformConfig.id, client, session, ui);
   }
   const enabledPlatforms = Array.from(platforms.entries()).filter(([id]) => platformEnabledState.get(id) ?? true);