@fickydev/pigent 0.1.21 → 0.1.22

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # Changelog
 
+## 0.1.22 - 2026-05-18
+
+### Added
+
+- Added `/skills` command to list all known skills with active/inactive flags and source labels for the current chat session.
+- Added session-scoped dynamic skill loading with `/skills add <skill>`, `/skills remove <skill>`, and `/skills clear`.
+- Added current skill inventory to each agent prompt so users can ask natural questions like "what skills do you have?".
+- Added `agent_sessions.session_skills` persistence and migration.
+
 ## 0.1.21 - 2026-05-18
 
 ### Fixed

package/TODO.md

@@ -146,6 +146,9 @@
 - [x] Make README more end-user facing
 - [x] Confirm per-agent system prompt injection
 - [x] Confirm per-agent skills loading
+- [x] Add `/skills` command for current session skills with active/inactive flags
+- [x] Add session-scoped dynamic skill loading via `/skills add/remove/clear`
+- [x] Add skill inventory context so agents can answer natural-language skill questions
 - [x] Confirm per-agent extensions loading
 - [ ] Confirm per-agent custom tools loading
 - [x] Prototype one prompt through Pi SDK

package/drizzle/migrations/0007_session_skills.sql

@@ -0,0 +1 @@
+ALTER TABLE `agent_sessions` ADD `session_skills` text DEFAULT '[]' NOT NULL;

package/drizzle/migrations/meta/_journal.json

@@ -50,6 +50,13 @@
       "when": 1779117599104,
       "tag": "0006_flippant_bruce_banner",
       "breakpoints": true
+    },
+    {
+      "idx": 7,
+      "version": "6",
+      "when": 1779120000000,
+      "tag": "0007_session_skills",
+      "breakpoints": true
     }
   ]
 }

package/package.json

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

package/src/agents/AgentRunner.ts

@@ -1,7 +1,9 @@
 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 type { Repositories } from "../db/repositories";
+import type { AgentSessionRow } from "../db/schema";
 import { logger } from "../logging/logger";
 import { PiAgentRunner } from "../pi/PiAgentRunner";
 import { createTaskTools, type TaskToolContext } from "../pi/tools/taskTools";
@@ -117,8 +119,8 @@ export class AgentRunner {
         agent,
         profile: this.registry.getProfile(agent.profile),
         session,
-        prompt: this.composePrompt(input, chatInstructions),
-        customTools: this.buildCustomTools(agent, input.message),
+        prompt: this.composePrompt(input, session, chatInstructions),
+        customTools: this.buildCustomTools(agent, session, input.message),
       });
 
       if (session.piSessionId !== result.piSessionId || session.piSessionPath !== result.piSessionPath) {
@@ -145,10 +147,10 @@ export class AgentRunner {
     }
   }
 
-  private buildCustomTools(agent: LoadedAgentConfig, message: InboundMessage): ToolDefinition[] | undefined {
+  private buildCustomTools(agent: LoadedAgentConfig, session: AgentSessionRow, message: InboundMessage): ToolDefinition[] | undefined {
     const tools: ToolDefinition[] = [];
 
-    if (this.hasSkill(agent, "task-management") && this.scheduler) {
+    if (this.hasSkill(agent, session, "task-management") && this.scheduler) {
       const ctx: TaskToolContext = {
         agentId: agent.id,
         channel: message.channel,
@@ -173,18 +175,17 @@ export class AgentRunner {
     return tools.length > 0 ? tools : undefined;
   }
 
-  private hasSkill(agent: LoadedAgentConfig, skillName: string): boolean {
+  private hasSkill(agent: LoadedAgentConfig, session: AgentSessionRow, skillName: string): boolean {
     const allSkills = [
       ...(agent.profile ? (this.registry.getProfile(agent.profile)?.defaultSkills ?? []) : []),
       ...agent.skills,
+      ...parseSessionSkills(session.sessionSkills),
     ];
-    return allSkills.some((s) => {
-      const base = s.split("/").pop() ?? s;
-      return base === skillName || s === skillName;
-    });
+
+    return hasSkillRef(allSkills, skillName);
   }
 
-  private composePrompt(input: AgentRunInput, chatInstructions: string): string {
+  private composePrompt(input: AgentRunInput, session: AgentSessionRow, chatInstructions: string): string {
     const parts: string[] = [
       `[Channel]\n${input.message.channel}`,
       `[Chat]\n${input.message.chatId}`,
@@ -202,11 +203,48 @@ export class AgentRunner {
       parts.push(`[Chat Instructions]\n${chatInstructions}`);
     }
 
+    const skillsContext = this.skillsContext(input.agentId, session);
+    if (skillsContext) {
+      parts.push(`[Skills]\n${skillsContext}`);
+    }
+
     parts.push(`[Message]\n${input.text}`);
 
     return parts.join("\n\n");
   }
 
+  private skillsContext(agentId: string, session: AgentSessionRow): string {
+    const agent = this.registry.getAgent(agentId);
+    if (!agent) return "";
+
+    const profile = this.registry.getProfile(agent.profile);
+    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 knownSkills = uniqueSkillRefs([...builtInSkills, ...activeSkills]).sort((a, b) =>
+      skillDisplayName(a).localeCompare(skillDisplayName(b)),
+    );
+
+    if (knownSkills.length === 0) return "No skills are configured or available.";
+
+    return knownSkills
+      .map((skill) => {
+        const name = skillDisplayName(skill);
+        const active = hasSkillRef(activeSkills, name);
+        const sources = [];
+
+        if (hasSkillRef(profileSkills, name)) sources.push("profile");
+        if (hasSkillRef(agentSkills, name)) sources.push("agent");
+        if (hasSkillRef(sessionSkills, name)) sources.push("session");
+        if (hasSkillRef(builtInSkills, name)) sources.push("built-in");
+
+        return `- ${name}: ${active ? "active" : "available, inactive"}${sources.length > 0 ? ` (${sources.join(", ")})` : ""}`;
+      })
+      .join("\n");
+  }
+
   private async chatInstructions(input: AgentRunInput): Promise<string> {
     if (input.message.channel !== "telegram") return "";
 

package/src/agents/BotCommandHandler.ts

@@ -1,6 +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 type { AgentSessionRow } from "../db/schema";
 import type { Repositories } from "../db/repositories";
 import { PiAgentRunner, type PiContextUsage } from "../pi/PiAgentRunner";
@@ -47,6 +48,8 @@ export class BotCommandHandler {
         return { handled: true, text: await this.newSessionText(message) };
       case "/status":
         return { handled: true, text: await this.statusText(message) };
+      case "/skills":
+        return { handled: true, text: await this.skillsText(message) };
       case "/model":
         return await this.modelResult(message);
       case "/thinking":
@@ -71,6 +74,9 @@ export class BotCommandHandler {
       "/agents - list agents for this chat",
       "/new - start a fresh session for this chat",
       "/status - show current session status",
+      "/skills - list skills for this chat session",
+      "/skills add <skill> - load a skill for this session",
+      "/skills remove <skill> - unload a session-loaded skill",
       "/model - show model picker for this chat session",
       "/model <provider/modelId> - set model for this chat session",
       "/model default - clear model override for this chat session",
@@ -191,6 +197,83 @@ export class BotCommandHandler {
     };
   }
 
+  private async skillsText(message: InboundMessage): Promise<string> {
+    const sessionResult = await this.getDefaultSession(message);
+    if (!sessionResult.ok) return sessionResult.message;
+
+    const [, actionRaw, ...args] = message.text.trim().split(/\s+/);
+    const action = actionRaw?.toLowerCase() ?? "list";
+    const skillRef = args.join(" ").trim();
+
+    if (action === "add") {
+      if (!skillRef) return "Usage: /skills add <skill>";
+
+      const current = parseSessionSkills(sessionResult.session.sessionSkills);
+      const next = uniqueSkillRefs([...current, skillRef]);
+      await this.repositories.sessions.updateSessionSkills(sessionResult.session.id, next);
+
+      return [
+        "Skill loaded for current session: " + skillRef,
+        "",
+        "It will be included on the next agent response in this chat session.",
+        "Use /skills to see active skills.",
+      ].join("\n");
+    }
+
+    if (action === "remove") {
+      if (!skillRef) return "Usage: /skills remove <skill>";
+
+      const current = parseSessionSkills(sessionResult.session.sessionSkills);
+      const next = current.filter((item) => item !== skillRef);
+      await this.repositories.sessions.updateSessionSkills(sessionResult.session.id, next);
+
+      return next.length === current.length
+        ? "Session skill not found: " + skillRef
+        : "Skill removed from current session: " + skillRef;
+    }
+
+    if (action === "clear") {
+      await this.repositories.sessions.updateSessionSkills(sessionResult.session.id, []);
+      return "Session-loaded skills cleared.";
+    }
+
+    if (action !== "list") {
+      return [
+        "Usage:",
+        "/skills - list skills",
+        "/skills add <skill> - load skill for this session",
+        "/skills remove <skill> - unload session skill",
+        "/skills clear - clear session-loaded skills",
+      ].join("\n");
+    }
+
+    const agent = sessionResult.agent;
+    const profile = this.registry.getProfile(agent.profile);
+    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 knownSkills = uniqueSkillRefs([...builtInSkills, ...activeSkills]).sort((a, b) =>
+      skillDisplayName(a).localeCompare(skillDisplayName(b)),
+    );
+
+    return [
+      "Skills for current session",
+      "",
+      "Agent: " + agent.id,
+      "Session: " + sessionResult.session.id,
+      "",
+      "Available skills:",
+      ...formatSkillRows(knownSkills, { profileSkills, agentSkills, sessionSkills, builtInSkills }),
+      "",
+      "Legend: ✅ active, ⬜ available but inactive",
+      "Load on the fly: /skills add <skill>",
+      "Unload: /skills remove <skill>",
+      "Clear session-loaded: /skills clear",
+    ].join("\n");
+  }
+
   private async modelResult(message: InboundMessage): Promise<BotCommandResult> {
     const sessionResult = await this.getDefaultSession(message);
     if (!sessionResult.ok) return { handled: true, text: sessionResult.message };
@@ -511,6 +594,33 @@ function formatDuration(ms: number): string {
   return Math.floor(hours / 24) + "d " + (hours % 24) + "h";
 }
 
+function formatSkillRows(
+  skills: string[],
+  sources: { profileSkills: string[]; agentSkills: string[]; sessionSkills: string[]; builtInSkills: string[] },
+): string[] {
+  if (skills.length === 0) return ["none"];
+
+  return skills.map((skill) => {
+    const name = skillDisplayName(skill);
+    const sourceLabels = [];
+
+    if (hasSkillRef(sources.profileSkills, name)) sourceLabels.push("profile");
+    if (hasSkillRef(sources.agentSkills, name)) sourceLabels.push("agent");
+    if (hasSkillRef(sources.sessionSkills, name)) sourceLabels.push("session");
+    if (hasSkillRef(sources.builtInSkills, name)) sourceLabels.push("built-in");
+
+    const active = sourceLabels.some((source) => source !== "built-in");
+    const marker = active ? "✅" : "⬜";
+    const sourceText = sourceLabels.length > 0 ? sourceLabels.join(", ") : "configured";
+
+    return `${marker} ${name} (${active ? "active" : "inactive"}; ${sourceText})`;
+  });
+}
+
+function formatList(items: string[]): string {
+  return items.length > 0 ? items.join(", ") : "none";
+}
+
 function formatPath(path: string): string {
   const home = process.env.HOME || process.env.USERPROFILE;
   if (home && path.startsWith(home)) {

package/src/config/skillRefs.ts

@@ -0,0 +1,50 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+
+export function parseSessionSkills(raw: string | null | undefined): string[] {
+  if (!raw) return [];
+
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed)) return [];
+
+    return parsed.filter((item): item is string => typeof item === "string" && item.trim().length > 0).map((item) => item.trim());
+  } catch {
+    return [];
+  }
+}
+
+export function skillDisplayName(ref: string): string {
+  const normalized = ref.replace(/\\/g, "/").replace(/\/$/, "");
+  return normalized.split("/").pop() || ref;
+}
+
+export function hasSkillRef(refs: string[], skillName: string): boolean {
+  return refs.some((ref) => ref === skillName || skillDisplayName(ref) === skillName);
+}
+
+export function uniqueSkillRefs(refs: string[]): string[] {
+  const seen = new Set<string>();
+  const unique: string[] = [];
+
+  for (const ref of refs.map((item) => item.trim()).filter(Boolean)) {
+    if (seen.has(ref)) continue;
+    seen.add(ref);
+    unique.push(ref);
+  }
+
+  return unique;
+}
+
+export function listBuiltInSkills(fromDir: string): string[] {
+  const skillsDir = resolve(fromDir, "../../skills");
+
+  if (!existsSync(skillsDir)) return [];
+
+  return readdirSync(skillsDir)
+    .filter((name) => {
+      const path = resolve(skillsDir, name);
+      return statSync(path).isDirectory() && existsSync(resolve(path, "SKILL.md"));
+    })
+    .sort();
+}

package/src/daemon/AgentDaemon.ts

@@ -181,6 +181,7 @@ function telegramCommands() {
     { command: "agents", description: "List agents available in this chat" },
     { command: "new", description: "Start a fresh chat session" },
     { command: "status", description: "Show current session status" },
+    { command: "skills", description: "List or load skills for this session" },
     { command: "model", description: "Choose model for this chat session" },
     { command: "thinking", description: "Choose thinking level for this chat session" },
     { command: "agent", description: "Send message to a specific agent" },

package/src/db/client.ts

@@ -30,6 +30,7 @@ function ensureRuntimeSchema(): void {
   ensureColumn("agent_sessions", "active", "ALTER TABLE `agent_sessions` ADD `active` integer DEFAULT true NOT NULL");
   ensureColumn("agent_sessions", "ended_at", "ALTER TABLE `agent_sessions` ADD `ended_at` integer");
   ensureColumn("agent_sessions", "pi_session_path", "ALTER TABLE `agent_sessions` ADD `pi_session_path` text");
+  ensureColumn("agent_sessions", "session_skills", "ALTER TABLE `agent_sessions` ADD `session_skills` text DEFAULT '[]' NOT NULL");
 }
 
 function ensureColumn(table: string, column: string, statement: string): void {

package/src/db/repositories/SessionRepository.ts

@@ -75,6 +75,18 @@ export class SessionRepository {
     return this.requireById(id);
   }
 
+  async updateSessionSkills(id: string, skills: string[]): Promise<AgentSessionRow> {
+    await this.db
+      .update(agentSessions)
+      .set({
+        sessionSkills: JSON.stringify(skills),
+        updatedAt: Date.now(),
+      })
+      .where(eq(agentSessions.id, id));
+
+    return this.requireById(id);
+  }
+
   async findById(id: string): Promise<AgentSessionRow | null> {
     const row = await this.db.query.agentSessions.findFirst({
       where: eq(agentSessions.id, id),

package/src/db/schema.ts

@@ -51,6 +51,7 @@ export const agentSessions = sqliteTable(
     instructionsHash: text("instructions_hash"),
     model: text("model"),
     thinkingLevel: text("thinking_level", { enum: ["off", "low", "medium", "high"] }),
+    sessionSkills: text("session_skills").notNull().default("[]"),
     active: integer("active", { mode: "boolean" }).notNull().default(true),
     endedAt: integer("ended_at"),
     createdAt: integer("created_at").notNull(),

package/src/pi/PiAgentRunner.ts

@@ -10,6 +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 type { AgentSessionRow } from "../db/schema";
 import { resolveModelSelection } from "./PiModelResolver";
 import { loadOrCreatePiSession } from "./PiSessionFactory";
@@ -82,7 +83,7 @@ export class PiAgentRunner {
       compaction: { enabled: false },
     });
     const agentDir = getAgentDir();
-    const skillPaths = resolveSkillPaths(input.agent, input.profile);
+    const skillPaths = resolveSkillPaths(input.agent, input.profile, input.session);
     const resourceLoader = new DefaultResourceLoader({
       cwd: workspace,
       agentDir,
@@ -114,7 +115,7 @@ export class PiAgentRunner {
   }
 }
 
-function resolveSkillPaths(agent: LoadedAgentConfig, profile: LoadedProfileConfig | null): string[] {
+function resolveSkillPaths(agent: LoadedAgentConfig, profile: LoadedProfileConfig | null, session: AgentSessionRow): string[] {
   const paths: string[] = [];
 
   if (profile) {
@@ -127,6 +128,10 @@ function resolveSkillPaths(agent: LoadedAgentConfig, profile: LoadedProfileConfi
     paths.push(resolveSkillPath(s, agent.baseDir));
   }
 
+  for (const s of parseSessionSkills(session.sessionSkills)) {
+    paths.push(resolveSkillPath(s, agent.baseDir));
+  }
+
   return paths;
 }