@fickydev/pigent 0.1.22 → 0.1.24

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## Unreleased
+
+## 0.1.24 - 2026-05-19
+
+### Added
+
+- Added Telegram working status UX with `sendChatAction` typing heartbeats and an editable `Working…` message while agent runs execute.
+
+## 0.1.23 - 2026-05-18
+
+### Fixed
+
+- Made `task-management` a runtime default active skill so task tools are available even when existing user configs do not list the skill.
+
 ## 0.1.22 - 2026-05-18
 
 ### Added

package/TODO.md

@@ -90,6 +90,8 @@
 - [ ] Implement `TelegramApi`
   - [x] `getUpdates`
   - [x] `sendMessage`
+  - [x] `editMessageText`
+  - [x] `sendChatAction`
   - [x] error handling
   - [x] retry/backoff
   - [x] `answerCallbackQuery`
@@ -100,6 +102,7 @@
   - [x] offset tracking
   - [x] graceful stop
   - [x] update normalization
+  - [x] visible working status with typing indicator and editable status message
 - [x] Persist Telegram offset in DB
 
 ## Routing
@@ -173,6 +176,7 @@
 - [x] Add max task runs per hour rate limit
 - [x] Add `/task status` or similar command
 - [x] Add task management as agent skill + tools (natural language task CRUD)
+- [x] Activate task-management by default for all sessions
 - [x] Improve task-management prompt guidance for reminder/proactive-message refusal
 
 ## Policy And Safety

package/package.json

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

package/src/agents/AgentRunner.ts

@@ -1,7 +1,7 @@
 import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import type { InboundMessage } from "../channels/types";
 import type { LoadedAgentConfig } from "../config/schemas";
-import { hasSkillRef, listBuiltInSkills, parseSessionSkills, skillDisplayName, uniqueSkillRefs } from "../config/skillRefs";
+import { defaultActiveSkills, hasSkillRef, listBuiltInSkills, parseSessionSkills, skillDisplayName, uniqueSkillRefs } from "../config/skillRefs";
 import type { Repositories } from "../db/repositories";
 import type { AgentSessionRow } from "../db/schema";
 import { logger } from "../logging/logger";
@@ -177,6 +177,7 @@ export class AgentRunner {
 
   private hasSkill(agent: LoadedAgentConfig, session: AgentSessionRow, skillName: string): boolean {
     const allSkills = [
+      ...defaultActiveSkills(),
       ...(agent.profile ? (this.registry.getProfile(agent.profile)?.defaultSkills ?? []) : []),
       ...agent.skills,
       ...parseSessionSkills(session.sessionSkills),
@@ -218,11 +219,12 @@ export class AgentRunner {
     if (!agent) return "";
 
     const profile = this.registry.getProfile(agent.profile);
+    const defaultSkills = defaultActiveSkills();
     const profileSkills = profile?.defaultSkills ?? [];
     const agentSkills = agent.skills;
     const sessionSkills = parseSessionSkills(session.sessionSkills);
     const builtInSkills = listBuiltInSkills(import.meta.dir);
-    const activeSkills = uniqueSkillRefs([...profileSkills, ...agentSkills, ...sessionSkills]);
+    const activeSkills = uniqueSkillRefs([...defaultSkills, ...profileSkills, ...agentSkills, ...sessionSkills]);
     const knownSkills = uniqueSkillRefs([...builtInSkills, ...activeSkills]).sort((a, b) =>
       skillDisplayName(a).localeCompare(skillDisplayName(b)),
     );
@@ -235,6 +237,7 @@ export class AgentRunner {
         const active = hasSkillRef(activeSkills, name);
         const sources = [];
 
+        if (hasSkillRef(defaultSkills, name)) sources.push("default");
         if (hasSkillRef(profileSkills, name)) sources.push("profile");
         if (hasSkillRef(agentSkills, name)) sources.push("agent");
         if (hasSkillRef(sessionSkills, name)) sources.push("session");

package/src/agents/BotCommandHandler.ts

@@ -1,7 +1,7 @@
 import { AuthStorage, ModelRegistry } from "@earendil-works/pi-coding-agent";
 import type { InboundMessage, InlineKeyboardButton } from "../channels/types";
 import type { LoadedAgentConfig, LoadedProfileConfig, ModelChoiceConfig } from "../config/schemas";
-import { hasSkillRef, listBuiltInSkills, parseSessionSkills, skillDisplayName, uniqueSkillRefs } from "../config/skillRefs";
+import { defaultActiveSkills, hasSkillRef, listBuiltInSkills, parseSessionSkills, skillDisplayName, uniqueSkillRefs } from "../config/skillRefs";
 import type { AgentSessionRow } from "../db/schema";
 import type { Repositories } from "../db/repositories";
 import { PiAgentRunner, type PiContextUsage } from "../pi/PiAgentRunner";
@@ -249,11 +249,12 @@ export class BotCommandHandler {
 
     const agent = sessionResult.agent;
     const profile = this.registry.getProfile(agent.profile);
+    const defaultSkills = defaultActiveSkills();
     const profileSkills = profile?.defaultSkills ?? [];
     const agentSkills = agent.skills;
     const sessionSkills = parseSessionSkills(sessionResult.session.sessionSkills);
     const builtInSkills = listBuiltInSkills(import.meta.dir);
-    const activeSkills = uniqueSkillRefs([...profileSkills, ...agentSkills, ...sessionSkills]);
+    const activeSkills = uniqueSkillRefs([...defaultSkills, ...profileSkills, ...agentSkills, ...sessionSkills]);
     const knownSkills = uniqueSkillRefs([...builtInSkills, ...activeSkills]).sort((a, b) =>
       skillDisplayName(a).localeCompare(skillDisplayName(b)),
     );
@@ -265,7 +266,7 @@ export class BotCommandHandler {
       "Session: " + sessionResult.session.id,
       "",
       "Available skills:",
-      ...formatSkillRows(knownSkills, { profileSkills, agentSkills, sessionSkills, builtInSkills }),
+      ...formatSkillRows(knownSkills, { defaultSkills, profileSkills, agentSkills, sessionSkills, builtInSkills }),
       "",
       "Legend: ✅ active, ⬜ available but inactive",
       "Load on the fly: /skills add <skill>",
@@ -596,7 +597,7 @@ function formatDuration(ms: number): string {
 
 function formatSkillRows(
   skills: string[],
-  sources: { profileSkills: string[]; agentSkills: string[]; sessionSkills: string[]; builtInSkills: string[] },
+  sources: { defaultSkills: string[]; profileSkills: string[]; agentSkills: string[]; sessionSkills: string[]; builtInSkills: string[] },
 ): string[] {
   if (skills.length === 0) return ["none"];
 
@@ -604,6 +605,7 @@ function formatSkillRows(
     const name = skillDisplayName(skill);
     const sourceLabels = [];
 
+    if (hasSkillRef(sources.defaultSkills, name)) sourceLabels.push("default");
     if (hasSkillRef(sources.profileSkills, name)) sourceLabels.push("profile");
     if (hasSkillRef(sources.agentSkills, name)) sourceLabels.push("agent");
     if (hasSkillRef(sources.sessionSkills, name)) sourceLabels.push("session");

package/src/channels/telegram/TelegramApi.ts

@@ -1,7 +1,9 @@
 import type {
   TelegramAnswerCallbackQueryResponse,
+  TelegramEditMessageTextResponse,
   TelegramGetMeResponse,
   TelegramGetUpdatesResponse,
+  TelegramSendChatActionResponse,
   TelegramSendMessageResponse,
   TelegramSetMyCommandsResponse,
   TelegramUpdate,
@@ -68,14 +70,39 @@ export class TelegramApi {
     text: string;
     threadId?: string | null;
     inlineKeyboard?: InlineKeyboardButton[][];
-  }): Promise<void> {
-    await this.request<TelegramSendMessageResponse>("sendMessage", {
+  }): Promise<number | null> {
+    const response = await this.request<TelegramSendMessageResponse>("sendMessage", {
       chat_id: input.chatId,
       text: input.text,
       message_thread_id: input.threadId ? Number(input.threadId) : undefined,
       disable_web_page_preview: true,
       reply_markup: input.inlineKeyboard ? toTelegramInlineKeyboard(input.inlineKeyboard) : undefined,
     });
+
+    return response.result?.message_id ?? null;
+  }
+
+  async editMessageText(input: {
+    chatId: string;
+    messageId: number;
+    text: string;
+    inlineKeyboard?: InlineKeyboardButton[][];
+  }): Promise<void> {
+    await this.request<TelegramEditMessageTextResponse>("editMessageText", {
+      chat_id: input.chatId,
+      message_id: input.messageId,
+      text: input.text,
+      disable_web_page_preview: true,
+      reply_markup: input.inlineKeyboard ? toTelegramInlineKeyboard(input.inlineKeyboard) : undefined,
+    });
+  }
+
+  async sendChatAction(input: { chatId: string; action: "typing"; threadId?: string | null }): Promise<void> {
+    await this.request<TelegramSendChatActionResponse>("sendChatAction", {
+      chat_id: input.chatId,
+      action: input.action,
+      message_thread_id: input.threadId ? Number(input.threadId) : undefined,
+    });
   }
 
   async answerCallbackQuery(input: { callbackQueryId: string; text?: string }): Promise<void> {

package/src/channels/telegram/TelegramPollingAdapter.ts

@@ -1,6 +1,6 @@
 import type { RuntimeKvRepository } from "../../db/repositories/RuntimeKvRepository";
 import { logger } from "../../logging/logger";
-import type { ChannelAdapter, InboundMessage, MessageHandler, OutboundMessage } from "../types";
+import type { ChannelAdapter, InboundMessage, MessageHandler, OutboundMessage, RunStatusHandle } from "../types";
 import { TelegramApi, type TelegramBotCommand } from "./TelegramApi";
 import type { TelegramCallbackQuery, TelegramMessage, TelegramUpdate } from "./types";
 
@@ -63,6 +63,14 @@ export class TelegramPollingAdapter implements ChannelAdapter {
     });
   }
 
+  createRunStatus(message: OutboundMessage): RunStatusHandle {
+    if (message.channel !== "telegram") {
+      throw new Error(`unsupported channel for telegram adapter: ${message.channel}`);
+    }
+
+    return new TelegramRunStatusHandle(this.options.api, message);
+  }
+
   private async poll(handler: MessageHandler): Promise<void> {
     while (this.running) {
       try {
@@ -161,6 +169,84 @@ function normalizeTelegramCallbackQuery(updateId: number, callbackQuery: Telegra
   };
 }
 
+class TelegramRunStatusHandle implements RunStatusHandle {
+  private messageId: number | null = null;
+  private typingTimer: ReturnType<typeof setInterval> | null = null;
+
+  constructor(
+    private readonly api: TelegramApi,
+    private readonly message: OutboundMessage,
+  ) {}
+
+  async start(): Promise<void> {
+    await this.sendTyping();
+    this.messageId = await this.api.sendMessage({
+      chatId: this.message.chatId,
+      threadId: this.message.threadId,
+      text: this.message.text,
+    });
+
+    this.typingTimer = setInterval(() => {
+      void this.sendTyping();
+    }, 4000);
+  }
+
+  async complete(message: OutboundMessage): Promise<void> {
+    await this.stopAndPublish(message);
+  }
+
+  async fail(message: OutboundMessage): Promise<void> {
+    await this.stopAndPublish(message);
+  }
+
+  private async stopAndPublish(message: OutboundMessage): Promise<void> {
+    this.stopTyping();
+
+    if (this.messageId) {
+      try {
+        await this.api.editMessageText({
+          chatId: message.chatId,
+          messageId: this.messageId,
+          text: message.text,
+          inlineKeyboard: message.inlineKeyboard,
+        });
+        return;
+      } catch (error) {
+        logger.warn("telegram status edit failed; sending final message", {
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+
+    await this.api.sendMessage({
+      chatId: message.chatId,
+      threadId: message.threadId,
+      text: message.text,
+      inlineKeyboard: message.inlineKeyboard,
+    });
+  }
+
+  private async sendTyping(): Promise<void> {
+    try {
+      await this.api.sendChatAction({
+        chatId: this.message.chatId,
+        threadId: this.message.threadId,
+        action: "typing",
+      });
+    } catch (error) {
+      logger.debug("telegram typing indicator failed", {
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  private stopTyping(): void {
+    if (!this.typingTimer) return;
+    clearInterval(this.typingTimer);
+    this.typingTimer = null;
+  }
+}
+
 function sleep(ms: number): Promise<void> {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/src/channels/telegram/types.ts

@@ -63,6 +63,18 @@ export type TelegramAnswerCallbackQueryResponse = {
   description?: string;
 };
 
+export type TelegramEditMessageTextResponse = {
+  ok: boolean;
+  result?: TelegramMessage | boolean;
+  description?: string;
+};
+
+export type TelegramSendChatActionResponse = {
+  ok: boolean;
+  result: boolean;
+  description?: string;
+};
+
 export type TelegramSetMyCommandsResponse = {
   ok: boolean;
   result: boolean;

package/src/channels/types.ts

@@ -30,9 +30,16 @@ export type OutboundMessage = {
 
 export type MessageHandler = (message: InboundMessage) => Promise<void>;
 
+export interface RunStatusHandle {
+  start(): Promise<void>;
+  complete(message: OutboundMessage): Promise<void>;
+  fail(message: OutboundMessage): Promise<void>;
+}
+
 export interface ChannelAdapter {
   readonly id: ChannelId;
   start(handler: MessageHandler): Promise<void>;
   stop(): Promise<void>;
   send(message: OutboundMessage): Promise<void>;
+  createRunStatus?(message: OutboundMessage): RunStatusHandle;
 }

package/src/config/skillRefs.ts

@@ -1,6 +1,12 @@
 import { existsSync, readdirSync, statSync } from "node:fs";
 import { resolve } from "node:path";
 
+export const DEFAULT_ACTIVE_SKILLS = ["task-management"] as const;
+
+export function defaultActiveSkills(): string[] {
+  return [...DEFAULT_ACTIVE_SKILLS];
+}
+
 export function parseSessionSkills(raw: string | null | undefined): string[] {
   if (!raw) return [];
 

package/src/daemon/AgentDaemon.ts

@@ -117,18 +117,54 @@ export class AgentDaemon {
       return;
     }
 
-    const response = await this.runner.run({
-      agentId: route.agentId,
-      text: route.text,
-      message,
-    });
-
-    await this.send({
+    const status = this.createRunStatus({
       channel: message.channel,
       chatId: message.chatId,
       threadId: message.threadId,
-      text: response,
+      text: "Working…",
     });
+
+    await status?.start();
+
+    try {
+      const response = await this.runner.run({
+        agentId: route.agentId,
+        text: route.text,
+        message,
+      });
+
+      const outbound = {
+        channel: message.channel,
+        chatId: message.chatId,
+        threadId: message.threadId,
+        text: response,
+      };
+
+      if (status) {
+        await status.complete(outbound);
+      } else {
+        await this.send(outbound);
+      }
+    } catch (error) {
+      const failure = {
+        channel: message.channel,
+        chatId: message.chatId,
+        threadId: message.threadId,
+        text: "Agent failed to respond. Please try again later.",
+      };
+
+      if (status) {
+        await status.fail(failure);
+      } else {
+        await this.send(failure);
+      }
+
+      logger.error("agent run failed", {
+        channel: message.channel,
+        chatId: message.chatId,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
   }
 
   private async autoConfigureChat(message: InboundMessage): Promise<void> {
@@ -142,13 +178,25 @@ export class AgentDaemon {
   }
 
   private async send(message: OutboundMessage): Promise<void> {
-    const adapter = this.adapters.find((candidate) => candidate.id === message.channel);
+    const adapter = this.findAdapter(message.channel);
+    if (!adapter) return;
+
+    await adapter.send(message);
+  }
+
+  private createRunStatus(message: OutboundMessage) {
+    const adapter = this.findAdapter(message.channel);
+    return adapter?.createRunStatus?.(message) ?? null;
+  }
+
+  private findAdapter(channel: OutboundMessage["channel"]): ChannelAdapter | null {
+    const adapter = this.adapters.find((candidate) => candidate.id === channel);
     if (!adapter) {
-      logger.warn("no adapter available for outbound message", { channel: message.channel });
-      return;
+      logger.warn("no adapter available for outbound message", { channel });
+      return null;
     }
 
-    await adapter.send(message);
+    return adapter;
   }
 }
 

package/src/pi/PiAgentRunner.ts

@@ -10,7 +10,7 @@ import {
 import { mkdir } from "node:fs/promises";
 import { resolve } from "node:path";
 import type { LoadedAgentConfig, LoadedProfileConfig } from "../config/schemas";
-import { parseSessionSkills } from "../config/skillRefs";
+import { defaultActiveSkills, parseSessionSkills } from "../config/skillRefs";
 import type { AgentSessionRow } from "../db/schema";
 import { resolveModelSelection } from "./PiModelResolver";
 import { loadOrCreatePiSession } from "./PiSessionFactory";
@@ -118,6 +118,10 @@ export class PiAgentRunner {
 function resolveSkillPaths(agent: LoadedAgentConfig, profile: LoadedProfileConfig | null, session: AgentSessionRow): string[] {
   const paths: string[] = [];
 
+  for (const s of defaultActiveSkills()) {
+    paths.push(resolveSkillPath(s, agent.baseDir));
+  }
+
   if (profile) {
     for (const s of profile.defaultSkills) {
       paths.push(resolveSkillPath(s, profile.baseDir));