@fickydev/pigent 0.1.10 → 0.1.11

package/CHANGELOG.md

@@ -13,6 +13,9 @@
 - Added `task_configs` table and `TaskConfigRepository` for runtime task CRUD.
 - Added `/task list`, `/task create <intervalMs> <prompt>`, `/task remove <id>` Telegram commands.
 - Scheduler loads tasks from both config file and database, supports hot-add and hot-remove.
+- Scheduler now shares AgentRunner's per-session lock instead of using its own PiAgentRunner.
+- Tasks skip message persistence (inbound/outbound) in AgentRunner to avoid DB noise.
+- Added `source` field to InboundMessage type (`"user"` default, `"task"` for scheduled runs).
 
 - Added `bunx @fickydev/pigent <dir>` scaffold/setup/run CLI path.
 - Added one-command setup-and-run CLI at `src/cli/run.ts` and `bun run run`.

package/PLAN.md

@@ -77,17 +77,18 @@ Skill is Pi-compatible instruction bundle, usually a `SKILL.md` folder. Agents c
 
 Extension is Pi-compatible TypeScript/JavaScript module that adds tools, hooks, commands, or runtime behavior. Agents can load different extensions.
 
-### Heartbeat
+### Scheduled Tasks
 
-Heartbeat is scheduled self-activation. It prompts an agent periodically to check tasks, channels, external state, or pending work.
+Scheduled tasks are periodic self-activations defined in `pigent.yaml` or created at runtime via `/task create`. Each task references an agent, an interval, a prompt, and a target channel.
 
-Heartbeat must avoid spam via:
+The global `Scheduler` ticks on a configurable interval and evaluates every task's due-ness against its last run timestamp.
 
-- `NOOP` convention
-- cooldowns
-- dedupe
-- max messages per hour
-- lock per agent/session
+Constraints:
+
+- `NOOP` convention — agent returns "NOOP" to skip output
+- Per-task lock — prevent stacking runs of the same task
+- Max messages per hour — rate limit (not yet implemented)
+- Tasks must share the same session lock as user messages to avoid concurrent Pi runs for the same agent+channel+chat
 
 ## Target Architecture
 
@@ -252,9 +253,10 @@ Initial entities:
 - telegram chats
 - telegram chat agents
 - messages
-- heartbeats
+- task_runs (history)
+- task_configs (runtime task definitions)
+- runtime_kv (offsets, daemon state)
 - session model/thinking overrides
-- tasks/events later
 
 SQLite first. Keep schema types portable so PostgreSQL migration is straightforward.
 
@@ -282,7 +284,8 @@ src/
 
   daemon/
     AgentDaemon.ts
-    HeartbeatScheduler.ts
+    Scheduler.ts
+    taskDue.ts
 
   channels/
     types.ts
@@ -299,15 +302,19 @@ src/
 
   pi/
     PiAgentRunner.ts
-    PiSessionFactory.ts
+    PiAvailableModels.ts
+    PiModelResolver.ts
 
   db/
     client.ts
     schema.ts
     repositories/
       AgentRepository.ts
+      HeartbeatRepository.ts
       MessageRepository.ts
       SessionRepository.ts
+      TaskRepository.ts
+      TaskConfigRepository.ts
       TelegramRepository.ts
 
   config/
@@ -384,13 +391,16 @@ drizzle/
 - return responses
 - persist inbound/outbound messages
 
-### Milestone 7: Heartbeat
+### Milestone 7: Scheduler
 
-- scheduler
-- per-agent lock
+- global scheduler tick
+- config-based tasks from `pigent.yaml`
+- DB-based tasks (runtime CRUD via `/task` commands)
+- per-task lock
+- shared session lock with user messages (prevent concurrent Pi runs)
 - `NOOP` handling
-- notification cooldown
-- heartbeat history
+- notification rate limits (future)
+- `/task list`, `/task create`, `/task remove` commands
 
 ### Milestone 8: Safety
 
@@ -425,8 +435,9 @@ Add Hono only after daemon works. Use it for:
 
 - Should `/model <agentId> ...` support non-default agent sessions in the command itself?
 - Should model availability errors block `/model` saves or save with a warning?
-- Which Pi SDK session manager should be used for persistent sessions?
 - How exactly should per-agent skills/extensions be loaded into Pi runtime?
 - Should group instructions live in YAML, DB, or both?
 - Should each chat have one default agent or multiple active agents?
 - What minimum approval flow is needed before shell/file-write tools?
+- Should scheduled tasks share the same session lock as user messages, or allow concurrent Pi runs?
+- Should `/task create` enforce permission checks before allowing runtime task creation?

package/TODO.md

@@ -160,6 +160,7 @@
 - [x] Add `/task create <intervalMs> <prompt>` command
 - [x] Add `/task remove <id>` command
 - [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)
 - [ ] Add max task runs per hour rate limit
 - [ ] Add `/task status` or similar command
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fickydev/pigent",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "private": false,
   "type": "module",
   "description": "Autonomous multi-agent daemon using Pi as core execution engine.",

package/src/agents/AgentRunner.ts

@@ -1,6 +1,5 @@
 import type { InboundMessage } from "../channels/types";
 import type { Repositories } from "../db/repositories";
-import type { AgentSessionRow } from "../db/schema";
 import { logger } from "../logging/logger";
 import { PiAgentRunner } from "../pi/PiAgentRunner";
 import type { AgentRegistry } from "./AgentRegistry";
@@ -11,17 +10,12 @@ export type AgentRunInput = {
   message: InboundMessage;
 };
 
-type AgentRunResponse = {
-  text: string;
-  error?: string;
-};
-
 function sessionLockKey(input: AgentRunInput): string {
   return [input.agentId, input.message.channel, input.message.chatId, input.message.threadId ?? ""].join(":");
 }
 
 export class AgentRunner {
-  private readonly piRunner = new PiAgentRunner();
+  readonly piRunner = new PiAgentRunner();
   private readonly sessionLocks = new Map<string, Promise<void>>();
 
   constructor(
@@ -41,42 +35,38 @@ export class AgentRunner {
       threadId: input.message.threadId,
     });
 
-    await this.repositories.messages.create({
-      agentId: input.agentId,
-      sessionId: session.id,
-      channel: input.message.channel,
-      direction: "inbound",
-      senderId: input.message.senderId,
-      chatId: input.message.chatId,
-      threadId: input.message.threadId,
-      content: input.text,
-      rawJson: input.message.raw,
-    });
-
-    const chatInstructions = await this.chatInstructions(input);
-    const response = await this.createResponse(input, session, chatInstructions);
-
-    if (response.error) {
+    // Skip DB persistence for task-triggered runs (Scheduler handles its own tracking)
+    if (input.message.source !== "task") {
       await this.repositories.messages.create({
         agentId: input.agentId,
         sessionId: session.id,
         channel: input.message.channel,
-        direction: "internal",
+        direction: "inbound",
+        senderId: input.message.senderId,
         chatId: input.message.chatId,
         threadId: input.message.threadId,
-        content: response.error,
+        content: input.text,
+        rawJson: input.message.raw,
       });
     }
 
-    await this.repositories.messages.create({
-      agentId: input.agentId,
-      sessionId: session.id,
-      channel: input.message.channel,
-      direction: "outbound",
-      chatId: input.message.chatId,
-      threadId: input.message.threadId,
-      content: response.text,
-    });
+    const chatInstructions = await this.chatInstructions(input);
+    const response = await this.createResponse(input, session, chatInstructions);
+
+    if (!response.handlerError) {
+      // Task runs persist their own messages via TaskRepository
+      if (input.message.source !== "task") {
+        await this.repositories.messages.create({
+          agentId: input.agentId,
+          sessionId: session.id,
+          channel: input.message.channel,
+          direction: "outbound",
+          chatId: input.message.chatId,
+          threadId: input.message.threadId,
+          content: response.text,
+        });
+      }
+    }
 
     return response.text;
   }
@@ -103,9 +93,9 @@ export class AgentRunner {
 
   private async createResponse(
     input: AgentRunInput,
-    session: AgentSessionRow,
+    session: any,
     chatInstructions: string,
-  ): Promise<AgentRunResponse> {
+  ): Promise<{ text: string; handlerError?: string }> {
     if (process.env.PIGENT_FAKE_AGENT === "1") {
       return { text: this.fakeResponse(input.agentId, input.text) };
     }
@@ -131,26 +121,34 @@ export class AgentRunner {
       });
 
       if (process.env.PIGENT_FALLBACK_FAKE_AGENT === "1") {
-        return { text: this.fakeResponse(input.agentId, input.text), error: errorMessage };
+        return { text: this.fakeResponse(input.agentId, input.text), handlerError: errorMessage };
       }
 
-      return { text: "Agent failed to respond. Please try again later.", error: errorMessage };
+      return { text: "Agent failed to respond. Please try again later.", handlerError: errorMessage };
     }
   }
 
   private composePrompt(input: AgentRunInput, chatInstructions: string): string {
-    return [
+    const parts: string[] = [
       `[Channel]\n${input.message.channel}`,
       `[Chat]\n${input.message.chatId}`,
-      input.message.threadId ? `[Thread]\n${input.message.threadId}` : null,
-      input.message.senderName || input.message.senderId
-        ? `[User]\n${input.message.senderName ?? input.message.senderId}`
-        : null,
-      chatInstructions ? `[Chat Instructions]\n${chatInstructions}` : null,
-      `[Message]\n${input.text}`,
-    ]
-      .filter(Boolean)
-      .join("\n\n");
+    ];
+
+    if (input.message.threadId) {
+      parts.push(`[Thread]\n${input.message.threadId}`);
+    }
+
+    if (input.message.senderName || input.message.senderId) {
+      parts.push(`[User]\n${input.message.senderName ?? input.message.senderId}`);
+    }
+
+    if (chatInstructions) {
+      parts.push(`[Chat Instructions]\n${chatInstructions}`);
+    }
+
+    parts.push(`[Message]\n${input.text}`);
+
+    return parts.join("\n\n");
   }
 
   private async chatInstructions(input: AgentRunInput): Promise<string> {

package/src/channels/types.ts

@@ -1,5 +1,7 @@
 export type ChannelId = "telegram";
 
+export type MessageSource = "user" | "task";
+
 export type InboundMessage = {
   id: string;
   channel: ChannelId;
@@ -10,6 +12,7 @@ export type InboundMessage = {
   text: string;
   raw: unknown;
   receivedAt: Date;
+  source?: MessageSource;
 };
 
 export type InlineKeyboardButton = {

package/src/daemon/AgentDaemon.ts

@@ -26,10 +26,10 @@ export class AgentDaemon {
   ) {
     this.adapters = createAdapters(repositories);
     this.registry = new AgentRegistry(config, repositories);
-    this.scheduler = new Scheduler(config.scheduler, this.registry, repositories, this.adapters);
+    this.runner = new AgentRunner(this.registry, repositories);
+    this.scheduler = new Scheduler(config.scheduler, this.registry, repositories, this.adapters, this.runner);
     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);
   }
 
   static async create(): Promise<AgentDaemon> {

package/src/daemon/Scheduler.ts

@@ -2,8 +2,8 @@ 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 { AgentRunner } from "../agents/AgentRunner";
 import type { ChannelAdapter } from "../channels/types";
 import { isTaskDue } from "./taskDue";
 
@@ -11,7 +11,6 @@ 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(
@@ -19,6 +18,7 @@ export class Scheduler {
     private readonly registry: AgentRegistry,
     private readonly repositories: Repositories,
     private readonly adapters: ChannelAdapter[],
+    private readonly agentRunner: AgentRunner,
   ) {}
 
   async start(): Promise<void> {
@@ -124,8 +124,7 @@ export class Scheduler {
   }
 
   private async runTaskIfDue(task: TaskConfig): Promise<void> {
-    const lockKey = task.id;
-    if (this.taskLocks.get(lockKey)) return;
+    if (this.taskLocks.get(task.id)) return;
 
     const lastRun = await this.repositories.taskRuns.findLatest(task.agent, task.id);
     if (!isTaskDue(lastRun?.createdAt ?? null, task.intervalMs)) return;
@@ -136,12 +135,12 @@ export class Scheduler {
       return;
     }
 
-    this.taskLocks.set(lockKey, true);
+    this.taskLocks.set(task.id, true);
 
     try {
       await this.executeTask(task, agent);
     } finally {
-      this.taskLocks.set(lockKey, false);
+      this.taskLocks.set(task.id, false);
     }
   }
 
@@ -157,21 +156,21 @@ export class Scheduler {
     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,
+      // Use AgentRunner to run the prompt — shares the session lock with user messages
+      const response = await this.agentRunner.run({
+        agentId: task.agent,
+        text: fullPrompt,
+        message: {
+          id: "task:" + task.id,
+          channel: task.channel as any,
+          chatId: task.chatId!,
+          text: fullPrompt,
+          raw: { type: "task", taskId: task.id },
+          receivedAt: new Date(),
+          source: "task",
+        },
       });
 
       const trimmed = response.trim();