feat(session): add daily reset policy

Co-authored-by: Austin Mudd <austinm911@gmail.com>

src/auto-reply/reply/session.test.ts

@@ -2,7 +2,7 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 
 import type { ClawdbotConfig } from "../../config/config.js";
 import { saveSessionStore } from "../../config/sessions.js";
@@ -170,3 +170,141 @@ describe("initSessionState RawBody", () => {
     expect(result.triggerBodyNormalized).toBe("/status");
   });
 });
+
+describe("initSessionState reset policy", () => {
+  it("defaults to daily reset at 4am local time", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(2026, 0, 18, 5, 0, 0));
+    try {
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-reset-daily-"));
+      const storePath = path.join(root, "sessions.json");
+      const sessionKey = "agent:main:whatsapp:dm:S1";
+      const existingSessionId = "daily-session-id";
+
+      await saveSessionStore(storePath, {
+        [sessionKey]: {
+          sessionId: existingSessionId,
+          updatedAt: new Date(2026, 0, 18, 3, 0, 0).getTime(),
+        },
+      });
+
+      const cfg = { session: { store: storePath } } as ClawdbotConfig;
+      const result = await initSessionState({
+        ctx: { Body: "hello", SessionKey: sessionKey },
+        cfg,
+        commandAuthorized: true,
+      });
+
+      expect(result.isNewSession).toBe(true);
+      expect(result.sessionId).not.toBe(existingSessionId);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("expires sessions when idle timeout wins over daily reset", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(2026, 0, 18, 5, 30, 0));
+    try {
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-reset-idle-"));
+      const storePath = path.join(root, "sessions.json");
+      const sessionKey = "agent:main:whatsapp:dm:S2";
+      const existingSessionId = "idle-session-id";
+
+      await saveSessionStore(storePath, {
+        [sessionKey]: {
+          sessionId: existingSessionId,
+          updatedAt: new Date(2026, 0, 18, 4, 45, 0).getTime(),
+        },
+      });
+
+      const cfg = {
+        session: {
+          store: storePath,
+          reset: { mode: "daily", atHour: 4, idleMinutes: 30 },
+        },
+      } as ClawdbotConfig;
+      const result = await initSessionState({
+        ctx: { Body: "hello", SessionKey: sessionKey },
+        cfg,
+        commandAuthorized: true,
+      });
+
+      expect(result.isNewSession).toBe(true);
+      expect(result.sessionId).not.toBe(existingSessionId);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("uses per-type overrides for thread sessions", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(2026, 0, 18, 5, 0, 0));
+    try {
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-reset-thread-"));
+      const storePath = path.join(root, "sessions.json");
+      const sessionKey = "agent:main:slack:channel:C1:thread:123";
+      const existingSessionId = "thread-session-id";
+
+      await saveSessionStore(storePath, {
+        [sessionKey]: {
+          sessionId: existingSessionId,
+          updatedAt: new Date(2026, 0, 18, 3, 0, 0).getTime(),
+        },
+      });
+
+      const cfg = {
+        session: {
+          store: storePath,
+          reset: { mode: "daily", atHour: 4 },
+          resetByType: { thread: { mode: "idle", idleMinutes: 180 } },
+        },
+      } as ClawdbotConfig;
+      const result = await initSessionState({
+        ctx: { Body: "reply", SessionKey: sessionKey, ThreadLabel: "Slack thread" },
+        cfg,
+        commandAuthorized: true,
+      });
+
+      expect(result.isNewSession).toBe(false);
+      expect(result.sessionId).toBe(existingSessionId);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
+  it("keeps legacy idleMinutes behavior without reset config", async () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(2026, 0, 18, 5, 0, 0));
+    try {
+      const root = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-reset-legacy-"));
+      const storePath = path.join(root, "sessions.json");
+      const sessionKey = "agent:main:whatsapp:dm:S3";
+      const existingSessionId = "legacy-session-id";
+
+      await saveSessionStore(storePath, {
+        [sessionKey]: {
+          sessionId: existingSessionId,
+          updatedAt: new Date(2026, 0, 18, 3, 30, 0).getTime(),
+        },
+      });
+
+      const cfg = {
+        session: {
+          store: storePath,
+          idleMinutes: 240,
+        },
+      } as ClawdbotConfig;
+      const result = await initSessionState({
+        ctx: { Body: "hello", SessionKey: sessionKey },
+        cfg,
+        commandAuthorized: true,
+      });
+
+      expect(result.isNewSession).toBe(false);
+      expect(result.sessionId).toBe(existingSessionId);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+});

src/auto-reply/reply/session.ts

@@ -6,11 +6,14 @@ import { CURRENT_SESSION_VERSION, SessionManager } from "@mariozechner/pi-coding
 import { resolveSessionAgentId } from "../../agents/agent-scope.js";
 import type { ClawdbotConfig } from "../../config/config.js";
 import {
-  DEFAULT_IDLE_MINUTES,
   DEFAULT_RESET_TRIGGERS,
   deriveSessionMetaPatch,
+  evaluateSessionFreshness,
+  isThreadSessionKey,
   type GroupKeyResolution,
   loadSessionStore,
+  resolveSessionResetPolicy,
+  resolveSessionResetType,
   resolveGroupSessionKey,
   resolveSessionFilePath,
   resolveSessionKey,
@@ -105,7 +108,6 @@ export async function initSessionState(params: {
   const resetTriggers = sessionCfg?.resetTriggers?.length
     ? sessionCfg.resetTriggers
     : DEFAULT_RESET_TRIGGERS;
-  const idleMinutes = Math.max(sessionCfg?.idleMinutes ?? DEFAULT_IDLE_MINUTES, 1);
   const sessionScope = sessionCfg?.scope ?? "per-sender";
   const storePath = resolveStorePath(sessionCfg?.store, { agentId });
 
@@ -170,8 +172,18 @@ export async function initSessionState(params: {
   sessionKey = resolveSessionKey(sessionScope, sessionCtxForState, mainKey);
   const entry = sessionStore[sessionKey];
   const previousSessionEntry = resetTriggered && entry ? { ...entry } : undefined;
-  const idleMs = idleMinutes * 60_000;
-  const freshEntry = entry && Date.now() - entry.updatedAt <= idleMs;
+  const now = Date.now();
+  const isThread =
+    ctx.MessageThreadId != null ||
+    Boolean(ctx.ThreadLabel?.trim()) ||
+    Boolean(ctx.ThreadStarterBody?.trim()) ||
+    Boolean(ctx.ParentSessionKey?.trim()) ||
+    isThreadSessionKey(sessionKey);
+  const resetType = resolveSessionResetType({ sessionKey, isGroup, isThread });
+  const resetPolicy = resolveSessionResetPolicy({ sessionCfg, resetType });
+  const freshEntry = entry
+    ? evaluateSessionFreshness({ updatedAt: entry.updatedAt, now, policy: resetPolicy }).fresh
+    : false;
 
   if (!isNewSession && freshEntry) {
     sessionId = entry.sessionId;

src/commands/agent/session.ts

@@ -9,9 +9,11 @@ import {
 } from "../../auto-reply/thinking.js";
 import type { ClawdbotConfig } from "../../config/config.js";
 import {
-  DEFAULT_IDLE_MINUTES,
+  evaluateSessionFreshness,
   loadSessionStore,
   resolveAgentIdFromSessionKey,
+  resolveSessionResetPolicy,
+  resolveSessionResetType,
   resolveSessionKey,
   resolveStorePath,
   type SessionEntry,
@@ -38,8 +40,6 @@ export function resolveSession(opts: {
   const sessionCfg = opts.cfg.session;
   const scope = sessionCfg?.scope ?? "per-sender";
   const mainKey = normalizeMainKey(sessionCfg?.mainKey);
-  const idleMinutes = Math.max(sessionCfg?.idleMinutes ?? DEFAULT_IDLE_MINUTES, 1);
-  const idleMs = idleMinutes * 60_000;
   const explicitSessionKey = opts.sessionKey?.trim();
   const storeAgentId = resolveAgentIdFromSessionKey(explicitSessionKey);
   const storePath = resolveStorePath(sessionCfg?.store, {
@@ -68,7 +68,11 @@ export function resolveSession(opts: {
     }
   }
 
-  const fresh = sessionEntry && sessionEntry.updatedAt >= now - idleMs;
+  const resetType = resolveSessionResetType({ sessionKey });
+  const resetPolicy = resolveSessionResetPolicy({ sessionCfg, resetType });
+  const fresh = sessionEntry
+    ? evaluateSessionFreshness({ updatedAt: sessionEntry.updatedAt, now, policy: resetPolicy }).fresh
+    : false;
   const sessionId =
     opts.sessionId?.trim() || (fresh ? sessionEntry?.sessionId : undefined) || crypto.randomUUID();
   const isNewSession = !fresh && !opts.sessionId;

src/config/sessions.ts

@@ -2,6 +2,7 @@ export * from "./sessions/group.js";
 export * from "./sessions/metadata.js";
 export * from "./sessions/main-session.js";
 export * from "./sessions/paths.js";
+export * from "./sessions/reset.js";
 export * from "./sessions/session-key.js";
 export * from "./sessions/store.js";
 export * from "./sessions/types.js";

src/config/sessions/reset.ts

@@ -0,0 +1,116 @@
+import type { SessionConfig } from "../types.base.js";
+import { DEFAULT_IDLE_MINUTES } from "./types.js";
+
+export type SessionResetMode = "daily" | "idle";
+export type SessionResetType = "dm" | "group" | "thread";
+
+export type SessionResetPolicy = {
+  mode: SessionResetMode;
+  atHour: number;
+  idleMinutes?: number;
+};
+
+export type SessionFreshness = {
+  fresh: boolean;
+  dailyResetAt?: number;
+  idleExpiresAt?: number;
+};
+
+export const DEFAULT_RESET_MODE: SessionResetMode = "daily";
+export const DEFAULT_RESET_AT_HOUR = 4;
+
+const THREAD_SESSION_MARKERS = [":thread:", ":topic:"];
+const GROUP_SESSION_MARKERS = [":group:", ":channel:"];
+
+export function isThreadSessionKey(sessionKey?: string | null): boolean {
+  const normalized = (sessionKey ?? "").toLowerCase();
+  if (!normalized) return false;
+  return THREAD_SESSION_MARKERS.some((marker) => normalized.includes(marker));
+}
+
+export function resolveSessionResetType(params: {
+  sessionKey?: string | null;
+  isGroup?: boolean;
+  isThread?: boolean;
+}): SessionResetType {
+  if (params.isThread || isThreadSessionKey(params.sessionKey)) return "thread";
+  if (params.isGroup) return "group";
+  const normalized = (params.sessionKey ?? "").toLowerCase();
+  if (GROUP_SESSION_MARKERS.some((marker) => normalized.includes(marker))) return "group";
+  return "dm";
+}
+
+export function resolveDailyResetAtMs(now: number, atHour: number): number {
+  const normalizedAtHour = normalizeResetAtHour(atHour);
+  const resetAt = new Date(now);
+  resetAt.setHours(normalizedAtHour, 0, 0, 0);
+  if (now < resetAt.getTime()) {
+    resetAt.setDate(resetAt.getDate() - 1);
+  }
+  return resetAt.getTime();
+}
+
+export function resolveSessionResetPolicy(params: {
+  sessionCfg?: SessionConfig;
+  resetType: SessionResetType;
+  idleMinutesOverride?: number;
+}): SessionResetPolicy {
+  const sessionCfg = params.sessionCfg;
+  const baseReset = sessionCfg?.reset;
+  const typeReset = sessionCfg?.resetByType?.[params.resetType];
+  const hasExplicitReset = Boolean(baseReset || sessionCfg?.resetByType);
+  const legacyIdleMinutes = sessionCfg?.idleMinutes;
+  const mode =
+    typeReset?.mode ??
+    baseReset?.mode ??
+    (!hasExplicitReset && legacyIdleMinutes != null ? "idle" : DEFAULT_RESET_MODE);
+  const atHour = normalizeResetAtHour(typeReset?.atHour ?? baseReset?.atHour ?? DEFAULT_RESET_AT_HOUR);
+  const idleMinutesRaw =
+    params.idleMinutesOverride ??
+    typeReset?.idleMinutes ??
+    baseReset?.idleMinutes ??
+    legacyIdleMinutes;
+
+  let idleMinutes: number | undefined;
+  if (idleMinutesRaw != null) {
+    const normalized = Math.floor(idleMinutesRaw);
+    if (Number.isFinite(normalized)) {
+      idleMinutes = Math.max(normalized, 1);
+    }
+  } else if (mode === "idle") {
+    idleMinutes = DEFAULT_IDLE_MINUTES;
+  }
+
+  return { mode, atHour, idleMinutes };
+}
+
+export function evaluateSessionFreshness(params: {
+  updatedAt: number;
+  now: number;
+  policy: SessionResetPolicy;
+}): SessionFreshness {
+  const dailyResetAt =
+    params.policy.mode === "daily"
+      ? resolveDailyResetAtMs(params.now, params.policy.atHour)
+      : undefined;
+  const idleExpiresAt =
+    params.policy.idleMinutes != null
+      ? params.updatedAt + params.policy.idleMinutes * 60_000
+      : undefined;
+  const staleDaily = dailyResetAt != null && params.updatedAt < dailyResetAt;
+  const staleIdle = idleExpiresAt != null && params.now > idleExpiresAt;
+  return {
+    fresh: !(staleDaily || staleIdle),
+    dailyResetAt,
+    idleExpiresAt,
+  };
+}
+
+function normalizeResetAtHour(value: number | undefined): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return DEFAULT_RESET_AT_HOUR;
+  const normalized = Math.floor(value);
+  if (!Number.isFinite(normalized)) return DEFAULT_RESET_AT_HOUR;
+  if (normalized < 0) return 0;
+  if (normalized > 23) return 23;
+  return normalized;
+}

src/config/types.base.ts

@@ -55,6 +55,20 @@ export type SessionSendPolicyConfig = {
   rules?: SessionSendPolicyRule[];
 };
 
+export type SessionResetMode = "daily" | "idle";
+export type SessionResetConfig = {
+  mode?: SessionResetMode;
+  /** Local hour (0-23) for the daily reset boundary. */
+  atHour?: number;
+  /** Sliding idle window (minutes). When set with daily mode, whichever expires first wins. */
+  idleMinutes?: number;
+};
+export type SessionResetByTypeConfig = {
+  dm?: SessionResetConfig;
+  group?: SessionResetConfig;
+  thread?: SessionResetConfig;
+};
+
 export type SessionConfig = {
   scope?: SessionScope;
   /** DM session scoping (default: "main"). */
@@ -64,6 +78,8 @@ export type SessionConfig = {
   resetTriggers?: string[];
   idleMinutes?: number;
   heartbeatIdleMinutes?: number;
+  reset?: SessionResetConfig;
+  resetByType?: SessionResetByTypeConfig;
   store?: string;
   typingIntervalSeconds?: number;
   typingMode?: TypingMode;

src/config/zod-schema.session.ts

@@ -17,6 +17,38 @@ export const SessionSchema = z
     resetTriggers: z.array(z.string()).optional(),
     idleMinutes: z.number().int().positive().optional(),
     heartbeatIdleMinutes: z.number().int().positive().optional(),
+    reset: z
+      .object({
+        mode: z.union([z.literal("daily"), z.literal("idle")]).optional(),
+        atHour: z.number().int().min(0).max(23).optional(),
+        idleMinutes: z.number().int().positive().optional(),
+      })
+      .optional(),
+    resetByType: z
+      .object({
+        dm: z
+          .object({
+            mode: z.union([z.literal("daily"), z.literal("idle")]).optional(),
+            atHour: z.number().int().min(0).max(23).optional(),
+            idleMinutes: z.number().int().positive().optional(),
+          })
+          .optional(),
+        group: z
+          .object({
+            mode: z.union([z.literal("daily"), z.literal("idle")]).optional(),
+            atHour: z.number().int().min(0).max(23).optional(),
+            idleMinutes: z.number().int().positive().optional(),
+          })
+          .optional(),
+        thread: z
+          .object({
+            mode: z.union([z.literal("daily"), z.literal("idle")]).optional(),
+            atHour: z.number().int().min(0).max(23).optional(),
+            idleMinutes: z.number().int().positive().optional(),
+          })
+          .optional(),
+      })
+      .optional(),
     store: z.string().optional(),
     typingIntervalSeconds: z.number().int().positive().optional(),
     typingMode: z

src/web/auto-reply/heartbeat-runner.ts

@@ -89,7 +89,11 @@ export async function runWebHeartbeatOnce(opts: {
         sessionKey: sessionSnapshot.key,
         sessionId: sessionId ?? sessionSnapshot.entry?.sessionId ?? null,
         sessionFresh: sessionSnapshot.fresh,
-        idleMinutes: sessionSnapshot.idleMinutes,
+        resetMode: sessionSnapshot.resetPolicy.mode,
+        resetAtHour: sessionSnapshot.resetPolicy.atHour,
+        idleMinutes: sessionSnapshot.resetPolicy.idleMinutes ?? null,
+        dailyResetAt: sessionSnapshot.dailyResetAt ?? null,
+        idleExpiresAt: sessionSnapshot.idleExpiresAt ?? null,
       },
       "heartbeat session snapshot",
     );

src/web/auto-reply/session-snapshot.ts

@@ -1,7 +1,9 @@
 import type { loadConfig } from "../../config/config.js";
 import {
-  DEFAULT_IDLE_MINUTES,
+  evaluateSessionFreshness,
   loadSessionStore,
+  resolveSessionResetPolicy,
+  resolveSessionResetType,
   resolveSessionKey,
   resolveStorePath,
 } from "../../config/sessions.js";
@@ -21,12 +23,24 @@ export function getSessionSnapshot(
   );
   const store = loadSessionStore(resolveStorePath(sessionCfg?.store));
   const entry = store[key];
-  const idleMinutes = Math.max(
-    (isHeartbeat
-      ? (sessionCfg?.heartbeatIdleMinutes ?? sessionCfg?.idleMinutes)
-      : sessionCfg?.idleMinutes) ?? DEFAULT_IDLE_MINUTES,
-    1,
-  );
-  const fresh = !!(entry && Date.now() - entry.updatedAt <= idleMinutes * 60_000);
-  return { key, entry, fresh, idleMinutes };
+  const resetType = resolveSessionResetType({ sessionKey: key });
+  const idleMinutesOverride = isHeartbeat ? sessionCfg?.heartbeatIdleMinutes : undefined;
+  const resetPolicy = resolveSessionResetPolicy({
+    sessionCfg,
+    resetType,
+    idleMinutesOverride,
+  });
+  const now = Date.now();
+  const freshness = entry
+    ? evaluateSessionFreshness({ updatedAt: entry.updatedAt, now, policy: resetPolicy })
+    : { fresh: false };
+  return {
+    key,
+    entry,
+    fresh: freshness.fresh,
+    resetPolicy,
+    resetType,
+    dailyResetAt: freshness.dailyResetAt,
+    idleExpiresAt: freshness.idleExpiresAt,
+  };
 }