@fickydev/pigent 0.1.16 → 0.1.19

package/drizzle/migrations/meta/_journal.json

@@ -43,6 +43,13 @@
       "when": 1779099900000,
       "tag": "0005_pi_session_path",
       "breakpoints": true
+    },
+    {
+      "idx": 6,
+      "version": "6",
+      "when": 1779117599104,
+      "tag": "0006_flippant_bruce_banner",
+      "breakpoints": true
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fickydev/pigent",
-  "version": "0.1.16",
+  "version": "0.1.19",
   "private": false,
   "type": "module",
   "description": "Autonomous multi-agent daemon using Pi as core execution engine.",
@@ -22,6 +22,7 @@
   ],
   "files": [
     "src",
+    "skills",
     "agents",
     "profiles",
     "drizzle",

package/skills/task-management/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: task-management
+description: Manage scheduled tasks — list, create, update, and remove recurring prompts for this agent and chat.
+disable-model-invocation: false
+---
+
+# Task Management
+
+You can manage scheduled recurring tasks for this agent and chat.
+
+## Available Tools
+
+### `task_list`
+List all scheduled tasks for this agent and chat.
+
+### `task_create`
+Create a new scheduled task. Provide:
+- `prompt` (required): what to do at each interval. Be specific.
+- `intervalMs` (optional): how often to run. Default 600000 (10 minutes). Minimum 60000 (1 minute).
+
+When the task runs, if the result is "NOOP", nothing is sent to the user.
+
+### `task_update`
+Update an existing task's prompt or interval. Provide:
+- `id` (required): task ID
+- `prompt` (optional): new prompt text
+- `intervalMs` (optional): new interval in milliseconds
+
+### `task_remove`
+Remove a scheduled task by ID.
+
+## Limits
+
+- Maximum 5 tasks per agent per chat.
+- Minimum interval: 1 minute.
+
+## When to Use
+
+- User asks to "check something periodically" or "monitor something"
+- User asks to "run something every X minutes/hours"
+- User wants to change or stop a recurring task
+- User asks "what tasks do I have?" or "what's running?"
+
+## Examples
+
+User: "check my build every 5 minutes"
+→ task_create({ prompt: "Check the build pipeline status. Report failures. NOOP if everything is green.", intervalMs: 300000 })
+
+User: "remind me to review PRs every hour"
+→ task_create({ prompt: "Check for open pull requests that need review. List them. NOOP if none.", intervalMs: 3600000 })
+
+User: "change the build checker to run every 2 minutes"
+→ task_list() to find the task, then task_update({ id: "abc123", intervalMs: 120000 })
+
+User: "stop the build checker"
+→ task_list() to find the task, then task_remove({ id: "abc123" })
+
+User: "what recurring tasks do I have?"
+→ task_list()

package/src/agents/AgentRegistry.ts

@@ -1,9 +1,9 @@
-import type { LoadedAgentConfig, LoadedConfig, ProfileConfig } from "../config/schemas";
+import type { LoadedAgentConfig, LoadedConfig, LoadedProfileConfig } from "../config/schemas";
 import type { Repositories } from "../db/repositories";
 
 export class AgentRegistry {
   private readonly agentsById: Map<string, LoadedAgentConfig>;
-  private readonly profilesById: Map<string, ProfileConfig>;
+  private readonly profilesById: Map<string, LoadedProfileConfig>;
 
   constructor(
     private readonly config: LoadedConfig,
@@ -23,7 +23,7 @@ export class AgentRegistry {
     return [...this.agentsById.values()];
   }
 
-  listProfiles(): ProfileConfig[] {
+  listProfiles(): LoadedProfileConfig[] {
     return [...this.profilesById.values()];
   }
 
@@ -31,7 +31,7 @@ export class AgentRegistry {
     return this.agentsById.get(id) ?? null;
   }
 
-  getProfile(id: string): ProfileConfig | null {
+  getProfile(id: string): LoadedProfileConfig | null {
     return this.profilesById.get(id) ?? null;
   }
 

package/src/agents/AgentRunner.ts

@@ -1,8 +1,12 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { InboundMessage } from "../channels/types";
+import type { LoadedAgentConfig } from "../config/schemas";
 import type { Repositories } from "../db/repositories";
 import { logger } from "../logging/logger";
 import { PiAgentRunner } from "../pi/PiAgentRunner";
+import { createTaskTools, type TaskToolContext } from "../pi/tools/taskTools";
 import type { AgentRegistry } from "./AgentRegistry";
+import type { Scheduler } from "../daemon/Scheduler";
 
 export type AgentRunInput = {
   agentId: string;
@@ -21,8 +25,13 @@ export class AgentRunner {
   constructor(
     private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
+    private scheduler: Scheduler | null = null,
   ) {}
 
+  setScheduler(scheduler: Scheduler): void {
+    this.scheduler = scheduler;
+  }
+
   async run(input: AgentRunInput): Promise<string> {
     return this.withSessionLock(input, () => this.runUnlocked(input));
   }
@@ -109,6 +118,7 @@ export class AgentRunner {
         profile: this.registry.getProfile(agent.profile),
         session,
         prompt: this.composePrompt(input, chatInstructions),
+        customTools: this.buildCustomTools(agent, input.message),
       });
 
       if (session.piSessionId !== result.piSessionId || session.piSessionPath !== result.piSessionPath) {
@@ -135,6 +145,45 @@ export class AgentRunner {
     }
   }
 
+  private buildCustomTools(agent: LoadedAgentConfig, message: InboundMessage): ToolDefinition[] | undefined {
+    const tools: ToolDefinition[] = [];
+
+    if (this.hasSkill(agent, "task-management") && this.scheduler) {
+      const ctx: TaskToolContext = {
+        agentId: agent.id,
+        channel: message.channel,
+        chatId: message.chatId,
+        taskConfigRepo: this.repositories.taskConfigs,
+        schedulerHotReload: async (action, task) => {
+          if (action === "add") {
+            const row = await this.repositories.taskConfigs.findById(task.id);
+            if (row) {
+              this.scheduler!.addDynamicTaskFromRow(row);
+            }
+          } else if (action === "remove") {
+            await this.scheduler!.removeDynamicTask(task.id);
+          } else if (action === "update") {
+            await this.scheduler!.reloadTasks();
+          }
+        },
+      };
+      tools.push(...createTaskTools(ctx));
+    }
+
+    return tools.length > 0 ? tools : undefined;
+  }
+
+  private hasSkill(agent: LoadedAgentConfig, skillName: string): boolean {
+    const allSkills = [
+      ...(agent.profile ? (this.registry.getProfile(agent.profile)?.defaultSkills ?? []) : []),
+      ...agent.skills,
+    ];
+    return allSkills.some((s) => {
+      const base = s.split("/").pop() ?? s;
+      return base === skillName || s === skillName;
+    });
+  }
+
   private composePrompt(input: AgentRunInput, chatInstructions: string): string {
     const parts: string[] = [
       `[Channel]\n${input.message.channel}`,

package/src/agents/BotCommandHandler.ts

@@ -1,6 +1,6 @@
 import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { InboundMessage, InlineKeyboardButton } from "../channels/types";
-import type { LoadedAgentConfig, ModelChoiceConfig, ProfileConfig } from "../config/schemas";
+import type { LoadedAgentConfig, LoadedProfileConfig, ModelChoiceConfig } from "../config/schemas";
 import type { AgentSessionRow } from "../db/schema";
 import type { Repositories } from "../db/repositories";
 import { PiAgentRunner, type PiContextUsage } from "../pi/PiAgentRunner";
@@ -169,7 +169,7 @@ export class BotCommandHandler {
     ].join("\n");
   }
 
-  private async loadPiStatus(session: AgentSessionRow, agent: LoadedAgentConfig, profile: ProfileConfig | null) {
+  private async loadPiStatus(session: AgentSessionRow, agent: LoadedAgentConfig, profile: LoadedProfileConfig | null) {
     try {
       return await this.piRunner.status({ agent, profile, session });
     } catch {

package/src/config/loadConfig.ts

@@ -1,11 +1,12 @@
 import { readdir, readFile } from "node:fs/promises";
 import { homedir } from "node:os";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import YAML from "yaml";
 import {
   AgentConfigSchema,
   type LoadedAgentConfig,
   type LoadedConfig,
+  type LoadedProfileConfig,
   ProfileConfigSchema,
   RootConfigSchema,
 } from "./schemas";
@@ -60,7 +61,7 @@ async function loadAgents(rootDir: string): Promise<LoadedAgentConfig[]> {
 async function loadProfiles(rootDir: string) {
   const profilesDir = join(rootDir, "profiles");
   const entries = await readdir(profilesDir, { withFileTypes: true }).catch(() => []);
-  const profiles = [];
+  const profiles: LoadedProfileConfig[] = [];
 
   for (const entry of entries) {
     if (!entry.isFile()) continue;
@@ -68,7 +69,8 @@ async function loadProfiles(rootDir: string) {
 
     const configPath = join(profilesDir, entry.name);
     const parsed = await readYamlFile(configPath);
-    profiles.push(ProfileConfigSchema.parse(parsed));
+    const profile = ProfileConfigSchema.parse(parsed);
+    profiles.push({ ...profile, baseDir: dirname(configPath) });
   }
 
   return profiles;

package/src/config/schemas.ts

@@ -18,6 +18,7 @@ export const TaskConfigSchema = z.object({
   prompt: z.string().min(1).default("If no useful action is needed, reply exactly: NOOP."),
   channel: z.string().default("telegram"),
   chatId: z.string().optional(),
+  maxRunsPerHour: z.number().int().nonnegative().default(12),
 });
 
 export const SchedulerConfigSchema = z.object({
@@ -102,9 +103,13 @@ export type LoadedAgentConfig = AgentConfig & {
   systemPrompt: string;
 };
 
+export type LoadedProfileConfig = ProfileConfig & {
+  baseDir: string;
+};
+
 export type LoadedConfig = {
   agents: LoadedAgentConfig[];
-  profiles: ProfileConfig[];
+  profiles: LoadedProfileConfig[];
   telegramChats: TelegramChatConfig[];
   modelChoices: ModelChoiceConfig[];
   scheduler: SchedulerConfig;

package/src/daemon/AgentDaemon.ts

@@ -28,6 +28,7 @@ export class AgentDaemon {
     this.registry = new AgentRegistry(config, repositories);
     this.runner = new AgentRunner(this.registry, repositories);
     this.scheduler = new Scheduler(config.scheduler, this.registry, repositories, this.adapters, this.runner);
+    this.runner.setScheduler(this.scheduler);
     this.commands = new BotCommandHandler(this.registry, repositories, config.modelChoices, this.scheduler);
     this.router = new MessageRouter(repositories, this.registry);
   }

package/src/daemon/Scheduler.ts

@@ -7,6 +7,8 @@ import type { AgentRunner } from "../agents/AgentRunner";
 import type { ChannelAdapter } from "../channels/types";
 import { isTaskDue } from "./taskDue";
 
+const ONE_HOUR_MS = 3_600_000;
+
 export class Scheduler {
   private running = false;
   private tickTimer: ReturnType<typeof setTimeout> | null = null;
@@ -70,6 +72,7 @@ export class Scheduler {
       prompt: saved.prompt,
       channel: saved.channel,
       chatId: saved.chatId,
+      maxRunsPerHour: saved.maxRunsPerHour ?? 12,
     });
 
     if (!this.running && this.tasks.length === 1) {
@@ -97,6 +100,34 @@ export class Scheduler {
     return removed;
   }
 
+  /** Add a task from an already-saved DB row (e.g., created by a tool). Hot-adds to scheduler. */
+  addDynamicTaskFromRow(row: TaskConfigRow): void {
+    // Avoid duplicates
+    if (this.tasks.some((t) => t.id === row.id)) return;
+
+    this.tasks.push({
+      id: row.id,
+      agent: row.agent,
+      intervalMs: row.intervalMs,
+      prompt: row.prompt,
+      channel: row.channel,
+      chatId: row.chatId,
+      maxRunsPerHour: row.maxRunsPerHour ?? 12,
+    });
+
+    if (!this.running && this.tasks.length === 1) {
+      this.running = true;
+      this.tick();
+      logger.info("scheduler started on first dynamic task");
+    }
+  }
+
+  /** Reload all tasks from config + DB. Used after task updates. */
+  async reloadTasks(): Promise<void> {
+    this.tasks = await this.loadAllTasks();
+    logger.info("scheduler tasks reloaded", { taskCount: this.tasks.length });
+  }
+
   private async loadAllTasks(): Promise<TaskConfig[]> {
     const configTasks: TaskConfig[] = this.schedulerConfig.tasks;
     const dbTasks = await this.repositories.taskConfigs.findAllEnabled();
@@ -108,6 +139,7 @@ export class Scheduler {
       prompt: row.prompt,
       channel: row.channel,
       chatId: row.chatId,
+      maxRunsPerHour: row.maxRunsPerHour ?? 12,
     }));
 
     return [...configTasks, ...dbTaskConfigs];
@@ -129,6 +161,23 @@ export class Scheduler {
     const lastRun = await this.repositories.taskRuns.findLatest(task.agent, task.id);
     if (!isTaskDue(lastRun?.createdAt ?? null, task.intervalMs)) return;
 
+    // Enforce hourly rate limit
+    const maxPerHour = task.maxRunsPerHour ?? 12;
+    const recentCount = await this.repositories.taskRuns.countRecentNotified(
+      task.agent,
+      task.id,
+      Date.now() - ONE_HOUR_MS,
+    );
+    if (recentCount >= maxPerHour) {
+      logger.warn("task rate limited — max runs per hour reached", {
+        taskId: task.id,
+        agent: task.agent,
+        recentCount,
+        maxPerHour,
+      });
+      return;
+    }
+
     const agent = this.registry.getAgent(task.agent);
     if (!agent) {
       logger.warn("task references unknown agent, skipping", { taskId: task.id, agent: task.agent });

package/src/db/repositories/TaskConfigRepository.ts

@@ -1,4 +1,4 @@
-import { eq } from "drizzle-orm";
+import { and, eq } from "drizzle-orm";
 import { nanoid } from "nanoid";
 import type { DbClient } from "../client";
 import { taskConfigs, type TaskConfigRow } from "../schema";
@@ -60,4 +60,20 @@ export class TaskConfigRepository {
       where: eq(taskConfigs.enabled, true),
     });
   }
+
+  async update(id: string, patch: { prompt?: string; intervalMs?: number }): Promise<TaskConfigRow | null> {
+    await this.db
+      .update(taskConfigs)
+      .set({ ...patch, updatedAt: Date.now() })
+      .where(eq(taskConfigs.id, id));
+
+    return this.findById(id);
+  }
+
+  async countByAgentAndChatId(agent: string, chatId: string): Promise<number> {
+    const rows = await this.db.query.taskConfigs.findMany({
+      where: and(eq(taskConfigs.agent, agent), eq(taskConfigs.chatId, chatId), eq(taskConfigs.enabled, true)),
+    });
+    return rows.length;
+  }
 }

package/src/db/schema.ts

@@ -116,6 +116,7 @@ export const taskConfigs = sqliteTable("task_configs", {
   channel: text("channel").notNull().default("telegram"),
   chatId: text("chat_id").notNull(),
   enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+  maxRunsPerHour: integer("max_runs_per_hour"),
   createdAt: integer("created_at").notNull(),
   updatedAt: integer("updated_at").notNull(),
 });

package/src/pi/PiAgentRunner.ts

@@ -5,19 +5,21 @@ import {
   ModelRegistry,
   getAgentDir,
   SettingsManager,
+  type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import { mkdir } from "node:fs/promises";
 import { resolve } from "node:path";
-import type { LoadedAgentConfig, ProfileConfig } from "../config/schemas";
+import type { LoadedAgentConfig, LoadedProfileConfig } from "../config/schemas";
 import type { AgentSessionRow } from "../db/schema";
 import { resolveModelSelection } from "./PiModelResolver";
 import { loadOrCreatePiSession } from "./PiSessionFactory";
 
 export type PiAgentRunInput = {
   agent: LoadedAgentConfig;
-  profile: ProfileConfig | null;
+  profile: LoadedProfileConfig | null;
   session: AgentSessionRow;
   prompt: string;
+  customTools?: ToolDefinition[];
 };
 
 export type PiContextUsage = {
@@ -80,11 +82,13 @@ export class PiAgentRunner {
       compaction: { enabled: false },
     });
     const agentDir = getAgentDir();
+    const skillPaths = resolveSkillPaths(input.agent, input.profile);
     const resourceLoader = new DefaultResourceLoader({
       cwd: workspace,
       agentDir,
       settingsManager,
       systemPromptOverride: () => systemPrompt,
+      additionalSkillPaths: skillPaths,
     });
     await resourceLoader.reload();
 
@@ -103,13 +107,41 @@ export class PiAgentRunner {
       settingsManager,
       agentDir,
       tools: [],
+      customTools: input.customTools,
     });
 
     return { session, piSession };
   }
 }
 
-function composeSystemPrompt(agent: LoadedAgentConfig, profile: ProfileConfig | null): string {
+function resolveSkillPaths(agent: LoadedAgentConfig, profile: LoadedProfileConfig | null): string[] {
+  const paths: string[] = [];
+
+  if (profile) {
+    for (const s of profile.defaultSkills) {
+      paths.push(resolveSkillPath(s, profile.baseDir));
+    }
+  }
+
+  for (const s of agent.skills) {
+    paths.push(resolveSkillPath(s, agent.baseDir));
+  }
+
+  return paths;
+}
+
+function resolveSkillPath(skillRef: string, baseDir: string): string {
+  // Absolute path
+  if (skillRef.startsWith("/")) return skillRef;
+  // Home-relative path
+  if (skillRef.startsWith("~/")) return resolve(skillRef);
+  // Explicit relative path
+  if (skillRef.startsWith("./") || skillRef.startsWith("../")) return resolve(baseDir, skillRef);
+  // Built-in pigent skill (bare name like "task-management")
+  return resolve(import.meta.dir, "../../skills", skillRef);
+}
+
+function composeSystemPrompt(agent: LoadedAgentConfig, profile: LoadedProfileConfig | null): string {
   return [
     profile?.instructions,
     agent.systemPrompt,

package/src/pi/tools/taskTools.ts

@@ -0,0 +1,188 @@
+import { Type } from "typebox";
+import { defineTool, type ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { TaskConfigRepository } from "../../db/repositories/TaskConfigRepository";
+
+export type TaskToolContext = {
+  agentId: string;
+  channel: string;
+  chatId: string;
+  taskConfigRepo: TaskConfigRepository;
+  schedulerHotReload: (action: "add" | "remove" | "update", task: { id: string }) => Promise<void>;
+};
+
+const MAX_TASKS_PER_CHAT = 5;
+
+export function createTaskTools(ctx: TaskToolContext): ToolDefinition[] {
+  return [
+    createTaskListTool(ctx),
+    createTaskCreateTool(ctx),
+    createTaskUpdateTool(ctx),
+    createTaskRemoveTool(ctx),
+  ];
+}
+
+function createTaskListTool(ctx: TaskToolContext): ToolDefinition {
+  return defineTool({
+    name: "task_list",
+    label: "List Scheduled Tasks",
+    description: "List all scheduled tasks for the current agent and chat.",
+    promptSnippet: "List scheduled tasks",
+    parameters: Type.Object({}),
+    async execute(_callId, _params, _signal, _onUpdate, _extCtx) {
+      const tasks = await ctx.taskConfigRepo.findAllByChatId(ctx.chatId);
+      const mine = tasks.filter((t) => t.agent === ctx.agentId && t.enabled);
+
+      if (mine.length === 0) {
+        return { content: [{ type: "text", text: "No scheduled tasks." }], details: { count: 0 } };
+      }
+
+      const lines = mine.map((t) => {
+        const mins = Math.round(t.intervalMs / 60_000);
+        return `- ${t.id}: "${t.prompt}" (every ${mins}m)`;
+      });
+
+      return {
+        content: [{ type: "text", text: `Scheduled tasks (${mine.length}):\n${lines.join("\n")}` }],
+        details: { count: mine.length, tasks: mine },
+      };
+    },
+  });
+}
+
+function createTaskCreateTool(ctx: TaskToolContext): ToolDefinition {
+  return defineTool({
+    name: "task_create",
+    label: "Create Scheduled Task",
+    description:
+      "Create a new scheduled task for the current agent and chat. " +
+      "The task will run the given prompt at the specified interval. " +
+      "If the prompt result is NOOP, nothing is sent to the chat. " +
+      `Maximum ${MAX_TASKS_PER_CHAT} tasks per agent per chat.`,
+    promptSnippet: "Create a scheduled task with a prompt and interval",
+    parameters: Type.Object({
+      prompt: Type.String({ description: "The prompt to run at each interval. Be specific about what to check or do." }),
+      intervalMs: Type.Optional(
+        Type.Number({ description: "Interval in milliseconds. Default: 600000 (10 minutes). Minimum: 60000 (1 minute)." }),
+      ),
+    }),
+    async execute(_callId, params, _signal, _onUpdate, _extCtx) {
+      const intervalMs = Math.max(60_000, params.intervalMs ?? 600_000);
+
+      const count = await ctx.taskConfigRepo.countByAgentAndChatId(ctx.agentId, ctx.chatId);
+      if (count >= MAX_TASKS_PER_CHAT) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Cannot create task: maximum ${MAX_TASKS_PER_CHAT} tasks per agent per chat reached. Remove an existing task first.`,
+            },
+          ],
+          details: { error: "max_tasks_reached", count },
+        };
+      }
+
+      const saved = await ctx.taskConfigRepo.create({
+        agent: ctx.agentId,
+        intervalMs,
+        prompt: params.prompt,
+        channel: ctx.channel,
+        chatId: ctx.chatId,
+      });
+
+      await ctx.schedulerHotReload("add", { id: saved.id });
+
+      const mins = Math.round(intervalMs / 60_000);
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Task created: ${saved.id}\nPrompt: "${params.prompt}"\nInterval: every ${mins}m`,
+          },
+        ],
+        details: { id: saved.id, intervalMs },
+      };
+    },
+  });
+}
+
+function createTaskUpdateTool(ctx: TaskToolContext): ToolDefinition {
+  return defineTool({
+    name: "task_update",
+    label: "Update Scheduled Task",
+    description: "Update the prompt or interval of an existing scheduled task.",
+    parameters: Type.Object({
+      id: Type.String({ description: "Task ID to update." }),
+      prompt: Type.Optional(Type.String({ description: "New prompt text." })),
+      intervalMs: Type.Optional(Type.Number({ description: "New interval in milliseconds. Minimum: 60000 (1 minute)." })),
+    }),
+    async execute(_callId, params, _signal, _onUpdate, _extCtx) {
+      if (!params.prompt && !params.intervalMs) {
+        return {
+          content: [{ type: "text", text: "Nothing to update. Provide at least a prompt or intervalMs." }],
+          details: { error: "no_changes" },
+        };
+      }
+
+      const existing = await ctx.taskConfigRepo.findById(params.id);
+      if (!existing || existing.agent !== ctx.agentId || existing.chatId !== ctx.chatId) {
+        return {
+          content: [{ type: "text", text: `Task not found: ${params.id}` }],
+          details: { error: "not_found" },
+        };
+      }
+
+      const patch: { prompt?: string; intervalMs?: number } = {};
+      if (params.prompt) patch.prompt = params.prompt;
+      if (params.intervalMs) patch.intervalMs = Math.max(60_000, params.intervalMs);
+
+      const updated = await ctx.taskConfigRepo.update(params.id, patch);
+      if (!updated) {
+        return {
+          content: [{ type: "text", text: `Failed to update task: ${params.id}` }],
+          details: { error: "update_failed" },
+        };
+      }
+
+      await ctx.schedulerHotReload("update", { id: params.id });
+
+      const mins = Math.round(updated.intervalMs / 60_000);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Task updated: ${updated.id}\nPrompt: "${updated.prompt}"\nInterval: every ${mins}m`,
+          },
+        ],
+        details: { id: updated.id },
+      };
+    },
+  });
+}
+
+function createTaskRemoveTool(ctx: TaskToolContext): ToolDefinition {
+  return defineTool({
+    name: "task_remove",
+    label: "Remove Scheduled Task",
+    description: "Remove a scheduled task by ID.",
+    parameters: Type.Object({
+      id: Type.String({ description: "Task ID to remove." }),
+    }),
+    async execute(_callId, params, _signal, _onUpdate, _extCtx) {
+      const existing = await ctx.taskConfigRepo.findById(params.id);
+      if (!existing || existing.agent !== ctx.agentId || existing.chatId !== ctx.chatId) {
+        return {
+          content: [{ type: "text", text: `Task not found: ${params.id}` }],
+          details: { error: "not_found" },
+        };
+      }
+
+      await ctx.taskConfigRepo.remove(params.id);
+      await ctx.schedulerHotReload("remove", { id: params.id });
+
+      return {
+        content: [{ type: "text", text: `Task removed: ${params.id}` }],
+        details: { id: params.id },
+      };
+    },
+  });
+}