@fickydev/pigent 0.1.8 → 0.1.10

package/pigent.yaml

@@ -1,7 +1,11 @@
 telegramChats: []
 modelChoices: []
+scheduler:
+  tickIntervalMs: 10000
+  tasks: []
 
-# Add choices to show buttons for /model.
+# Optional. If empty, /model uses Pi's currently available models automatically.
+# Add choices to curate or rename buttons for /model.
 #
 # modelChoices:
 #   - id: anthropic/claude-sonnet-4-5
@@ -19,3 +23,16 @@ modelChoices: []
 #       - assistant
 #     instructions: |
 #       Be concise.
+#
+# Scheduled tasks. Each task runs on interval and sends output to channel.
+# If the agent returns "NOOP", nothing is sent.
+#
+# scheduler:
+#   tickIntervalMs: 10000
+#   tasks:
+#     - id: monitor-build
+#       agent: assistant
+#       intervalMs: 30000
+#       prompt: Check the build pipeline. NOOP if nothing to report.
+#       channel: telegram
+#       chatId: "-100123456"

package/src/agents/BotCommandHandler.ts

@@ -1,8 +1,10 @@
 import type { InboundMessage, InlineKeyboardButton } from "../channels/types";
 import type { ModelChoiceConfig } from "../config/schemas";
 import type { Repositories } from "../db/repositories";
+import { getAvailableModelChoices } from "../pi/PiAvailableModels";
 import { isValidModelRef } from "../pi/PiModelResolver";
 import type { AgentRegistry } from "./AgentRegistry";
+import type { Scheduler } from "../daemon/Scheduler";
 
 export type BotCommandResult =
   | {
@@ -22,12 +24,15 @@ export class BotCommandHandler {
     private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
     private readonly modelChoices: ModelChoiceConfig[] = [],
+    private readonly scheduler?: Scheduler,
   ) {}
 
   async handle(message: InboundMessage): Promise<BotCommandResult> {
     const [command] = message.text.trim().split(/\s+/, 1);
 
     switch (command) {
+      case "/task":
+        return await this.taskResult(message);
       case "/help":
       case "/start":
         return { handled: true, text: this.helpText() };
@@ -61,6 +66,9 @@ export class BotCommandHandler {
       "/thinking - show thinking picker for this chat session",
       "/thinking <off|low|medium|high> - set thinking level for this chat session",
       "/thinking default - clear thinking override for this chat session",
+      "/task list - list scheduled tasks for this chat",
+      "/task create <intervalMs> <prompt> - create a scheduled task",
+      "/task remove <id> - remove a scheduled task",
       "/agent <agentId> <message> - send message to specific agent",
       "@agentId <message> - send message to specific agent",
     ].join("\n");
@@ -83,8 +91,8 @@ export class BotCommandHandler {
     }
 
     return [
-      `Default agent: ${chat.defaultAgentId ?? "none"}`,
-      `Allowed agents: ${allowedAgentIds.length > 0 ? allowedAgentIds.join(", ") : "none"}`,
+      "Default agent: " + (chat.defaultAgentId ?? "none"),
+      "Allowed agents: " + (allowedAgentIds.length > 0 ? allowedAgentIds.join(", ") : "none"),
     ].join("\n");
   }
 
@@ -96,16 +104,18 @@ export class BotCommandHandler {
     const value = args.join(" ").trim();
 
     if (!value) {
+      const choices = await this.loadModelChoices();
+
       return {
         handled: true,
         text: [
-          `Agent: ${sessionResult.agentId}`,
-          `Session model: ${sessionResult.session.model ?? "default"}`,
-          this.modelChoices.length > 0
+          "Agent: " + sessionResult.agentId,
+          "Session model: " + (sessionResult.session.model ?? "default"),
+          choices.length > 0
             ? "Choose a model:"
-            : "No model choices configured. Use /model <provider/modelId> to set manually.",
+            : "No available Pi models found. Configure provider auth or use /model <provider/modelId> manually.",
         ].join("\n"),
-        inlineKeyboard: this.modelChoices.length > 0 ? this.modelKeyboard() : undefined,
+        inlineKeyboard: choices.length > 0 ? this.modelKeyboard(choices) : undefined,
       };
     }
 
@@ -118,7 +128,7 @@ export class BotCommandHandler {
     }
 
     const session = await this.repositories.sessions.updateModel(sessionResult.session.id, value);
-    return { handled: true, text: `Session model for ${session.agentId} set to ${session.model}.` };
+    return { handled: true, text: "Session model for " + session.agentId + " set to " + session.model + "." };
   }
 
   private async thinkingResult(message: InboundMessage): Promise<BotCommandResult> {
@@ -132,8 +142,8 @@ export class BotCommandHandler {
       return {
         handled: true,
         text: [
-          `Agent: ${sessionResult.agentId}`,
-          `Session thinking level: ${sessionResult.session.thinkingLevel ?? "default"}`,
+          "Agent: " + sessionResult.agentId,
+          "Session thinking level: " + (sessionResult.session.thinkingLevel ?? "default"),
           "Choose thinking level:",
         ].join("\n"),
         inlineKeyboard: this.thinkingKeyboard(),
@@ -149,21 +159,22 @@ export class BotCommandHandler {
     }
 
     const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, value);
-    return { handled: true, text: `Session thinking level for ${session.agentId} set to ${session.thinkingLevel}.` };
+    return { handled: true, text: "Session thinking level for " + session.agentId + " set to " + session.thinkingLevel + "." };
   }
 
   private async setModelFromChoice(message: InboundMessage): Promise<string> {
     const sessionResult = await this.getDefaultSession(message);
     if (!sessionResult.ok) return sessionResult.message;
 
+    const choices = await this.loadModelChoices();
     const choiceIndex = Number(message.text.slice("/model:set:".length));
-    if (!Number.isSafeInteger(choiceIndex) || choiceIndex < 0 || choiceIndex >= this.modelChoices.length) {
+    if (!Number.isSafeInteger(choiceIndex) || choiceIndex < 0 || choiceIndex >= choices.length) {
       return "Unknown model choice.";
     }
 
-    const choice = this.modelChoices[choiceIndex];
+    const choice = choices[choiceIndex];
     const session = await this.repositories.sessions.updateModel(sessionResult.session.id, choice.id);
-    return `Session model for ${session.agentId} set to ${choice.label} (${session.model}).`;
+    return "Session model for " + session.agentId + " set to " + choice.label + " (" + session.model + ").";
   }
 
   private async clearModel(message: InboundMessage): Promise<string> {
@@ -171,7 +182,7 @@ export class BotCommandHandler {
     if (!sessionResult.ok) return sessionResult.message;
 
     const session = await this.repositories.sessions.updateModel(sessionResult.session.id, null);
-    return `Session model cleared for ${session.agentId}. Current: ${session.model ?? "default"}`;
+    return "Session model cleared for " + session.agentId + ". Current: " + (session.model ?? "default");
   }
 
   private async setThinkingFromCallback(message: InboundMessage): Promise<string> {
@@ -184,7 +195,7 @@ export class BotCommandHandler {
     }
 
     const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, value);
-    return `Session thinking level for ${session.agentId} set to ${session.thinkingLevel}.`;
+    return "Session thinking level for " + session.agentId + " set to " + session.thinkingLevel + ".";
   }
 
   private async clearThinking(message: InboundMessage): Promise<string> {
@@ -192,16 +203,109 @@ export class BotCommandHandler {
     if (!sessionResult.ok) return sessionResult.message;
 
     const session = await this.repositories.sessions.updateThinkingLevel(sessionResult.session.id, null);
-    return `Session thinking level cleared for ${session.agentId}. Current: ${session.thinkingLevel ?? "default"}`;
+    return "Session thinking level cleared for " + session.agentId + ". Current: " + (session.thinkingLevel ?? "default");
+  }
+
+  private async taskResult(message: InboundMessage): Promise<BotCommandResult> {
+    if (!this.scheduler) {
+      return { handled: true, text: "Scheduler is not available." };
+    }
+
+    const parts = message.text.trim().split(/\s+/);
+    const subcommand = parts[1];
+
+    if (subcommand === "list") {
+      return await this.taskList(message);
+    }
+
+    if (subcommand === "create") {
+      return await this.taskCreate(message, parts);
+    }
+
+    if (subcommand === "remove") {
+      return await this.taskRemove(parts);
+    }
+
+    return {
+      handled: true,
+      text: [
+        "Usage:",
+        "/task list - list scheduled tasks",
+        "/task create <intervalMs> <prompt> - create a task",
+        "/task remove <id> - remove a task",
+      ].join("\n"),
+    };
+  }
+
+  private async taskList(message: InboundMessage): Promise<BotCommandResult> {
+    const tasks = this.scheduler!.getTasks().filter((t) => t.chatId === message.chatId || !t.chatId);
+    if (tasks.length === 0) return { handled: true, text: "No scheduled tasks for this chat." };
+
+    const lines = tasks.map((t) => {
+      const truncated = t.prompt.length > 50 ? t.prompt.slice(0, 50) + "..." : t.prompt;
+      return "- " + t.id + ": " + t.agent + " every " + t.intervalMs + 'ms "' + truncated + '"';
+    });
+
+    return { handled: true, text: "Scheduled tasks:\n" + lines.join("\n") };
+  }
+
+  private async taskCreate(message: InboundMessage, parts: string[]): Promise<BotCommandResult> {
+    const intervalMs = Number(parts[2]);
+    if (!Number.isInteger(intervalMs) || intervalMs < 1000) {
+      return { handled: true, text: "Invalid interval. Use a number >= 1000 (milliseconds)." };
+    }
+
+    const prompt = parts.slice(3).join(" ").trim();
+    if (!prompt) {
+      return { handled: true, text: "Missing prompt. Usage: /task create <intervalMs> <prompt>" };
+    }
+
+    const chat = await this.repositories.telegram.findChat(message.chatId);
+    if (!chat?.defaultAgentId) {
+      return { handled: true, text: "No default agent configured for this chat. Set one first." };
+    }
+
+    const saved = await this.scheduler!.addDynamicTask({
+      agent: chat.defaultAgentId,
+      intervalMs,
+      prompt,
+      channel: "telegram",
+      chatId: message.chatId,
+    });
+
+    const msg = "Task created: " + saved.id + "\n"
+      + "Agent: " + saved.agent + "\n"
+      + "Interval: " + saved.intervalMs + "ms\n"
+      + "Prompt: " + saved.prompt;
+
+    return { handled: true, text: msg };
+  }
+
+  private async taskRemove(parts: string[]): Promise<BotCommandResult> {
+    const taskId = parts[2];
+    if (!taskId) {
+      return { handled: true, text: "Missing task id. Usage: /task remove <id>" };
+    }
+
+    const removed = await this.scheduler!.removeDynamicTask(taskId);
+    if (!removed) return { handled: true, text: "Task not found: " + taskId };
+
+    return { handled: true, text: "Task removed: " + taskId };
+  }
+
+  private async loadModelChoices(): Promise<ModelChoiceConfig[]> {
+    if (this.modelChoices.length > 0) return this.modelChoices;
+
+    return getAvailableModelChoices();
   }
 
-  private modelKeyboard(): InlineKeyboardButton[][] {
+  private modelKeyboard(choices: ModelChoiceConfig[]): InlineKeyboardButton[][] {
     const rows = chunk(
-      this.modelChoices.map((choice, index) => ({
+      choices.map((choice, index) => ({
         text: choice.label,
-        callbackData: `model:set:${index}`,
+        callbackData: "model:set:" + index,
       })),
-      2,
+      1,
     );
 
     rows.push([{ text: "Use default", callbackData: "model:default" }]);
@@ -240,11 +344,11 @@ export class BotCommandHandler {
     }
 
     if (!this.registry.hasAgent(agentId)) {
-      return { ok: false as const, message: `Unknown agent: ${agentId}` };
+      return { ok: false as const, message: "Unknown agent: " + agentId };
     }
 
     if (!(await this.repositories.telegram.isAgentAllowed(message.chatId, agentId))) {
-      return { ok: false as const, message: `Agent is not allowed in this chat: ${agentId}` };
+      return { ok: false as const, message: "Agent is not allowed in this chat: " + agentId };
     }
 
     const session = await this.repositories.sessions.getOrCreate({

package/src/config/loadConfig.ts

@@ -112,5 +112,6 @@ export async function loadConfig(options: LoadConfigOptions = {}): Promise<Loade
     profiles,
     telegramChats: rootConfig.telegramChats,
     modelChoices: rootConfig.modelChoices,
+    scheduler: rootConfig.scheduler,
   };
 }

package/src/config/schemas.ts

@@ -11,10 +11,18 @@ export const PermissionConfigSchema = z.object({
   blockedTools: z.array(z.string()).default([]),
 });
 
-export const HeartbeatConfigSchema = z.object({
-  enabled: z.boolean().default(false),
+export const TaskConfigSchema = z.object({
+  id: z.string().min(1),
+  agent: z.string().min(1),
   intervalMs: z.number().int().positive().default(600_000),
   prompt: z.string().min(1).default("If no useful action is needed, reply exactly: NOOP."),
+  channel: z.string().default("telegram"),
+  chatId: z.string().optional(),
+});
+
+export const SchedulerConfigSchema = z.object({
+  tickIntervalMs: z.number().int().positive().default(10_000),
+  tasks: z.array(TaskConfigSchema).default([]),
 });
 
 export const AgentTelegramChannelConfigSchema = z.object({
@@ -36,11 +44,6 @@ export const AgentConfigSchema = z.object({
   skills: z.array(z.string()).default([]),
   extensions: z.array(z.string()).default([]),
   channels: AgentChannelsConfigSchema.default({ telegram: { enabled: false } }),
-  heartbeat: HeartbeatConfigSchema.default({
-    enabled: false,
-    intervalMs: 600_000,
-    prompt: "If no useful action is needed, reply exactly: NOOP.",
-  }),
   permissions: PermissionConfigSchema.default({
     canRunShell: false,
     canEditFiles: false,
@@ -82,10 +85,12 @@ export const TelegramChatConfigSchema = z.object({
 export const RootConfigSchema = z.object({
   telegramChats: z.array(TelegramChatConfigSchema).default([]),
   modelChoices: z.array(ModelChoiceConfigSchema).default([]),
+  scheduler: SchedulerConfigSchema.default({ tickIntervalMs: 10_000, tasks: [] }),
 });
 
 export type PermissionConfig = z.infer<typeof PermissionConfigSchema>;
-export type HeartbeatConfig = z.infer<typeof HeartbeatConfigSchema>;
+export type TaskConfig = z.infer<typeof TaskConfigSchema>;
+export type SchedulerConfig = z.infer<typeof SchedulerConfigSchema>;
 export type AgentConfig = z.infer<typeof AgentConfigSchema>;
 export type ProfileConfig = z.infer<typeof ProfileConfigSchema>;
 export type TelegramChatConfig = z.infer<typeof TelegramChatConfigSchema>;
@@ -102,4 +107,5 @@ export type LoadedConfig = {
   profiles: ProfileConfig[];
   telegramChats: TelegramChatConfig[];
   modelChoices: ModelChoiceConfig[];
+  scheduler: SchedulerConfig;
 };

package/src/daemon/AgentDaemon.ts

@@ -9,6 +9,7 @@ import { loadConfig } from "../config/loadConfig";
 import type { LoadedConfig } from "../config/schemas";
 import { createRepositories, type Repositories } from "../db/repositories";
 import { logger } from "../logging/logger";
+import { Scheduler } from "./Scheduler";
 
 export class AgentDaemon {
   private running = false;
@@ -17,6 +18,7 @@ export class AgentDaemon {
   private readonly registry: AgentRegistry;
   private readonly router: MessageRouter;
   private readonly runner: AgentRunner;
+  private readonly scheduler: Scheduler;
 
   private constructor(
     private readonly config: LoadedConfig,
@@ -24,7 +26,8 @@ export class AgentDaemon {
   ) {
     this.adapters = createAdapters(repositories);
     this.registry = new AgentRegistry(config, repositories);
-    this.commands = new BotCommandHandler(this.registry, repositories, config.modelChoices);
+    this.scheduler = new Scheduler(config.scheduler, this.registry, repositories, this.adapters);
+    this.commands = new BotCommandHandler(this.registry, repositories, config.modelChoices, this.scheduler);
     this.router = new MessageRouter(repositories, this.registry);
     this.runner = new AgentRunner(this.registry, repositories);
   }
@@ -45,6 +48,8 @@ export class AgentDaemon {
       await adapter.start((message) => this.handleInboundMessage(message));
     }
 
+    await this.scheduler.start();
+
     logger.info("pigent daemon started", {
       agents: this.registry.listAgents().length,
       profiles: this.registry.listProfiles().length,
@@ -58,6 +63,8 @@ export class AgentDaemon {
 
     this.running = false;
 
+    this.scheduler.stop();
+
     for (const adapter of this.adapters) {
       await adapter.stop();
     }

package/src/daemon/Scheduler.ts

@@ -0,0 +1,224 @@
+import type { SchedulerConfig, TaskConfig } from "../config/schemas";
+import type { Repositories } from "../db/repositories";
+import type { TaskConfigRow } from "../db/schema";
+import { logger } from "../logging/logger";
+import { PiAgentRunner } from "../pi/PiAgentRunner";
+import type { AgentRegistry } from "../agents/AgentRegistry";
+import type { ChannelAdapter } from "../channels/types";
+import { isTaskDue } from "./taskDue";
+
+export class Scheduler {
+  private running = false;
+  private tickTimer: ReturnType<typeof setTimeout> | null = null;
+  private readonly taskLocks = new Map<string, boolean>();
+  private readonly piRunner = new PiAgentRunner();
+  private tasks: TaskConfig[] = [];
+
+  constructor(
+    private readonly schedulerConfig: SchedulerConfig,
+    private readonly registry: AgentRegistry,
+    private readonly repositories: Repositories,
+    private readonly adapters: ChannelAdapter[],
+  ) {}
+
+  async start(): Promise<void> {
+    if (this.running) return;
+
+    this.tasks = await this.loadAllTasks();
+
+    if (this.tasks.length === 0) {
+      logger.info("scheduler skipped — no tasks configured");
+      return;
+    }
+
+    this.running = true;
+    logger.info("scheduler started", {
+      tickIntervalMs: this.schedulerConfig.tickIntervalMs,
+      taskCount: this.tasks.length,
+    });
+    this.tick();
+  }
+
+  stop(): void {
+    if (!this.running) return;
+    this.running = false;
+    if (this.tickTimer !== null) {
+      clearTimeout(this.tickTimer);
+      this.tickTimer = null;
+    }
+    logger.info("scheduler stopped");
+  }
+
+  getTasks(): TaskConfig[] {
+    return [...this.tasks];
+  }
+
+  /** Add a runtime-created task (from Telegram). Saves to DB, hot-adds to scheduler. */
+  async addDynamicTask(input: {
+    agent: string;
+    intervalMs: number;
+    prompt: string;
+    channel: string;
+    chatId: string;
+  }): Promise<TaskConfigRow> {
+    const saved = await this.repositories.taskConfigs.create(input);
+
+    this.tasks.push({
+      id: saved.id,
+      agent: saved.agent,
+      intervalMs: saved.intervalMs,
+      prompt: saved.prompt,
+      channel: saved.channel,
+      chatId: saved.chatId,
+    });
+
+    if (!this.running && this.tasks.length === 1) {
+      // First task added, start scheduler
+      this.running = true;
+      this.tick();
+      logger.info("scheduler started on first dynamic task");
+    }
+
+    return saved;
+  }
+
+  /** Remove a runtime task. Deletes from DB, hot-removes from scheduler. */
+  async removeDynamicTask(id: string): Promise<boolean> {
+    const before = this.tasks.length;
+    this.tasks = this.tasks.filter((t) => t.id !== id);
+    await this.repositories.taskConfigs.remove(id);
+
+    const removed = this.tasks.length < before;
+
+    if (removed && this.tasks.length === 0 && this.running) {
+      this.stop();
+    }
+
+    return removed;
+  }
+
+  private async loadAllTasks(): Promise<TaskConfig[]> {
+    const configTasks: TaskConfig[] = this.schedulerConfig.tasks;
+    const dbTasks = await this.repositories.taskConfigs.findAllEnabled();
+
+    const dbTaskConfigs: TaskConfig[] = dbTasks.map((row) => ({
+      id: row.id,
+      agent: row.agent,
+      intervalMs: row.intervalMs,
+      prompt: row.prompt,
+      channel: row.channel,
+      chatId: row.chatId,
+    }));
+
+    return [...configTasks, ...dbTaskConfigs];
+  }
+
+  private tick(): void {
+    if (!this.running) return;
+
+    for (const task of this.tasks) {
+      this.runTaskIfDue(task);
+    }
+
+    this.tickTimer = setTimeout(() => this.tick(), this.schedulerConfig.tickIntervalMs);
+  }
+
+  private async runTaskIfDue(task: TaskConfig): Promise<void> {
+    const lockKey = task.id;
+    if (this.taskLocks.get(lockKey)) return;
+
+    const lastRun = await this.repositories.taskRuns.findLatest(task.agent, task.id);
+    if (!isTaskDue(lastRun?.createdAt ?? null, task.intervalMs)) return;
+
+    const agent = this.registry.getAgent(task.agent);
+    if (!agent) {
+      logger.warn("task references unknown agent, skipping", { taskId: task.id, agent: task.agent });
+      return;
+    }
+
+    this.taskLocks.set(lockKey, true);
+
+    try {
+      await this.executeTask(task, agent);
+    } finally {
+      this.taskLocks.set(lockKey, false);
+    }
+  }
+
+  private async executeTask(task: TaskConfig, agent: any): Promise<void> {
+    logger.info("task executing", { taskId: task.id, agentId: task.agent });
+
+    const run = await this.repositories.taskRuns.create({
+      agentId: task.agent,
+      taskId: task.id,
+      prompt: task.prompt,
+    });
+
+    await this.repositories.taskRuns.markRunning(run.id);
+
+    try {
+      const session = await this.repositories.sessions.getOrCreate({
+        agentId: task.agent,
+        channel: task.channel,
+        chatId: task.chatId ?? `task:${task.id}`,
+        threadId: null,
+      });
+
+      const fullPrompt = this.composeTaskPrompt(task);
+      const profile = this.registry.getProfile(agent.profile);
+
+      const response = await this.piRunner.run({
+        agent,
+        profile,
+        session,
+        prompt: fullPrompt,
+      });
+
+      const trimmed = response.trim();
+
+      if (trimmed.toUpperCase() === "NOOP") {
+        await this.repositories.taskRuns.markNoop(run.id, { result: response });
+        logger.info("task noop", { taskId: task.id });
+        return;
+      }
+
+      await this.repositories.taskRuns.markNotified(run.id, { result: response });
+      await this.sendToChannel(task, agent, response);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error("task failed", { taskId: task.id, error: errorMessage });
+      await this.repositories.taskRuns.markFailed(run.id, { error: errorMessage });
+    }
+  }
+
+  private async sendToChannel(task: TaskConfig, agent: any, text: string): Promise<void> {
+    const adapter = this.adapters.find((a) => a.id === task.channel);
+    if (!adapter) {
+      logger.warn("no adapter for task output", { taskId: task.id, channel: task.channel });
+      return;
+    }
+
+    if (!task.chatId) {
+      logger.warn("no chatId for task output", { taskId: task.id });
+      return;
+    }
+
+    await adapter.send({
+      channel: task.channel as any,
+      chatId: task.chatId,
+      text: `[${agent.name} / ${task.id}]\n${text}`,
+    });
+  }
+
+  private composeTaskPrompt(task: TaskConfig): string {
+    return [
+      `[Task: ${task.id}]`,
+      "",
+      task.prompt,
+      "",
+      "You are running as a scheduled task inside Pigent.",
+      "If no useful action is needed, reply exactly: NOOP.",
+      "Otherwise, reply with the result of your task.",
+    ].join("\n");
+  }
+}

package/src/daemon/taskDue.ts

@@ -0,0 +1,4 @@
+export function isTaskDue(lastRunCreatedAt: number | null, intervalMs: number, now = Date.now()): boolean {
+  if (lastRunCreatedAt === null) return true;
+  return now - lastRunCreatedAt >= intervalMs;
+}

package/src/db/repositories/TaskConfigRepository.ts

@@ -0,0 +1,63 @@
+import { eq } from "drizzle-orm";
+import { nanoid } from "nanoid";
+import type { DbClient } from "../client";
+import { taskConfigs, type TaskConfigRow } from "../schema";
+
+export type CreateTaskConfigInput = {
+  agent: string;
+  intervalMs: number;
+  prompt: string;
+  channel: string;
+  chatId: string;
+};
+
+export class TaskConfigRepository {
+  constructor(private readonly db: DbClient) {}
+
+  async create(input: CreateTaskConfigInput): Promise<TaskConfigRow> {
+    const id = nanoid(8);
+    const now = Date.now();
+
+    await this.db.insert(taskConfigs).values({
+      id,
+      agent: input.agent,
+      intervalMs: input.intervalMs,
+      prompt: input.prompt,
+      channel: input.channel,
+      chatId: input.chatId,
+      enabled: true,
+      createdAt: now,
+      updatedAt: now,
+    });
+
+    const row = await this.findById(id);
+    if (!row) throw new Error(`failed to create task config ${id}`);
+
+    return row;
+  }
+
+  async remove(id: string): Promise<void> {
+    await this.db.delete(taskConfigs).where(eq(taskConfigs.id, id));
+  }
+
+  async findById(id: string): Promise<TaskConfigRow | null> {
+    const row = await this.db.query.taskConfigs.findFirst({
+      where: eq(taskConfigs.id, id),
+    });
+
+    return row ?? null;
+  }
+
+  async findAllByChatId(chatId: string): Promise<TaskConfigRow[]> {
+    return this.db.query.taskConfigs.findMany({
+      where: eq(taskConfigs.chatId, chatId),
+      orderBy: (fields, { asc }) => [asc(fields.createdAt)],
+    });
+  }
+
+  async findAllEnabled(): Promise<TaskConfigRow[]> {
+    return this.db.query.taskConfigs.findMany({
+      where: eq(taskConfigs.enabled, true),
+    });
+  }
+}