@fickydev/pigent 0.1.18 → 0.1.20

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 0.1.20 - 2026-05-18
+
+### Fixed
+
+- Fixed custom tools (task_list, task_create, task_update, task_remove) being blocked by `tools: []` in PiAgentRunner. Changed to `noTools: "builtin"` which disables built-in tools but lets custom tools pass through the SDK's tool allowlist filter.
+
+## 0.1.19 - 2026-05-18
+
+### Added
+
+- Added task management as a built-in skill + tools. Agents with `task-management` in their `skills[]` can now list, create, update, and remove scheduled tasks via natural language.
+- Added `task_list`, `task_create`, `task_update`, `task_remove` Pi SDK custom tools.
+- Added `skills/task-management/SKILL.md` built-in skill document.
+- Skill path resolution now supports bare names (e.g., `task-management`) resolved against pigent's built-in skills directory.
+- Added `TaskConfigRepository.update()` and `countByAgentAndChatId()` methods.
+- Added `Scheduler.addDynamicTaskFromRow()` and `reloadTasks()` for tool-driven hot-reload.
+- AgentRunner now accepts optional Scheduler reference and builds per-run custom tools with agent+chat context.
+- Capped at 5 tasks per agent per chat.
+- Default assistant agent now includes `task-management` skill.
+
 ## 0.1.18 - 2026-05-18
 
 ### Added

package/TODO.md

@@ -146,7 +146,8 @@
 - [x] Make README more end-user facing
 - [x] Confirm per-agent system prompt injection
 - [x] Confirm per-agent skills loading
-- [ ] Confirm per-agent extensions loading
+- [x] Confirm per-agent extensions loading
+- [ ] Confirm per-agent custom tools loading
 - [x] Prototype one prompt through Pi SDK
 - [x] Decide CLI fallback strategy if SDK gaps appear
 
@@ -167,7 +168,8 @@
 - [x] Scheduler loads tasks from both config file + DB
 - [x] Share session lock between Scheduler and AgentRunner (prevent concurrent Pi runs for same agent+chat)
 - [x] Add max task runs per hour rate limit
-- [ ] Add `/task status` or similar command
+- [x] Add `/task status` or similar command
+- [x] Add task management as agent skill + tools (natural language task CRUD)
 
 ## Policy And Safety
 

package/agents/assistant/agent.yaml

@@ -5,7 +5,8 @@ model: null
 thinkingLevel: null
 workspace: ~/.pigent/workspaces/assistant
 systemPromptFile: ./SYSTEM.md
-skills: []
+skills:
+  - task-management
 extensions: []
 channels:
   telegram:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fickydev/pigent",
-  "version": "0.1.18",
+  "version": "0.1.20",
   "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/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/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

@@ -100,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();

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/pi/PiAgentRunner.ts

@@ -5,6 +5,7 @@ import {
   ModelRegistry,
   getAgentDir,
   SettingsManager,
+  type ToolDefinition,
 } from "@earendil-works/pi-coding-agent";
 import { mkdir } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -18,6 +19,7 @@ export type PiAgentRunInput = {
   profile: LoadedProfileConfig | null;
   session: AgentSessionRow;
   prompt: string;
+  customTools?: ToolDefinition[];
 };
 
 export type PiContextUsage = {
@@ -104,7 +106,8 @@ export class PiAgentRunner {
       sessionManager: piSession.manager,
       settingsManager,
       agentDir,
-      tools: [],
+      noTools: "builtin",
+      customTools: input.customTools,
     });
 
     return { session, piSession };
@@ -116,17 +119,28 @@ function resolveSkillPaths(agent: LoadedAgentConfig, profile: LoadedProfileConfi
 
   if (profile) {
     for (const s of profile.defaultSkills) {
-      paths.push(resolve(profile.baseDir, s));
+      paths.push(resolveSkillPath(s, profile.baseDir));
     }
   }
 
   for (const s of agent.skills) {
-    paths.push(resolve(agent.baseDir, s));
+    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,

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 },
+      };
+    },
+  });
+}