feat: add user-invocable skill commands

src/auto-reply/reply/commands-info.ts

@@ -1,4 +1,5 @@
 import { logVerbose } from "../../globals.js";
+import { listSkillCommandsForWorkspace } from "../skill-commands.js";
 import { buildCommandsMessage, buildHelpMessage } from "../status.js";
 import { buildStatusReply } from "./commands-status.js";
 import { buildContextReply } from "./commands-context-report.js";
@@ -28,9 +29,15 @@ export const handleCommandsListCommand: CommandHandler = async (params, allowTex
     );
     return { shouldContinue: false };
   }
+  const skillCommands =
+    params.skillCommands ??
+    listSkillCommandsForWorkspace({
+      workspaceDir: params.workspaceDir,
+      cfg: params.cfg,
+    });
   return {
     shouldContinue: false,
-    reply: { text: buildCommandsMessage(params.cfg) },
+    reply: { text: buildCommandsMessage(params.cfg, skillCommands) },
   };
 };
 

src/auto-reply/reply/commands-types.ts

@@ -1,6 +1,7 @@
 import type { ChannelId } from "../../channels/plugins/types.js";
 import type { ClawdbotConfig } from "../../config/config.js";
 import type { SessionEntry, SessionScope } from "../../config/sessions.js";
+import type { SkillCommandSpec } from "../../agents/skills.js";
 import type { MsgContext } from "../templating.js";
 import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "../thinking.js";
 import type { ReplyPayload } from "../types.js";
@@ -47,6 +48,7 @@ export type HandleCommandsParams = {
   model: string;
   contextTokens: number;
   isGroup: boolean;
+  skillCommands?: SkillCommandSpec[];
 };
 
 export type CommandHandlerResult = {

src/auto-reply/reply/get-reply-inline-actions.ts

@@ -11,6 +11,8 @@ import { isDirectiveOnly } from "./directive-handling.js";
 import type { createModelSelectionState } from "./model-selection.js";
 import { extractInlineSimpleCommand } from "./reply-inline.js";
 import type { TypingController } from "./typing.js";
+import { listSkillCommandsForWorkspace, resolveSkillCommandInvocation } from "../skill-commands.js";
+import { logVerbose } from "../../globals.js";
 
 export type InlineActionResult =
   | { kind: "reply"; reply: ReplyPayload | ReplyPayload[] | undefined }
@@ -55,6 +57,7 @@ export async function handleInlineActions(params: {
   contextTokens: number;
   directiveAck?: ReplyPayload;
   abortedLastRun: boolean;
+  skillFilter?: string[];
 }): Promise<InlineActionResult> {
   const {
     ctx,
@@ -89,11 +92,47 @@ export async function handleInlineActions(params: {
     contextTokens,
     directiveAck,
     abortedLastRun: initialAbortedLastRun,
+    skillFilter,
   } = params;
 
   let directives = initialDirectives;
   let cleanedBody = initialCleanedBody;
 
+  const shouldLoadSkillCommands = command.commandBodyNormalized.startsWith("/");
+  const skillCommands = shouldLoadSkillCommands
+    ? listSkillCommandsForWorkspace({
+        workspaceDir,
+        cfg,
+        skillFilter,
+      })
+    : [];
+
+  const skillInvocation =
+    allowTextCommands && skillCommands.length > 0
+      ? resolveSkillCommandInvocation({
+          commandBodyNormalized: command.commandBodyNormalized,
+          skillCommands,
+        })
+      : null;
+  if (skillInvocation) {
+    if (!command.isAuthorizedSender) {
+      logVerbose(
+        `Ignoring /${skillInvocation.command.name} from unauthorized sender: ${command.senderId || "<unknown>"}`,
+      );
+      typing.cleanup();
+      return { kind: "reply", reply: undefined };
+    }
+    const promptParts = [
+      `Use the "${skillInvocation.command.skillName}" skill for this request.`,
+      skillInvocation.args ? `User input:\n${skillInvocation.args}` : null,
+    ].filter((entry): entry is string => Boolean(entry));
+    const rewrittenBody = promptParts.join("\n\n");
+    ctx.Body = rewrittenBody;
+    sessionCtx.Body = rewrittenBody;
+    sessionCtx.BodyStripped = rewrittenBody;
+    cleanedBody = rewrittenBody;
+  }
+
   const sendInlineReply = async (reply?: ReplyPayload) => {
     if (!reply) return;
     if (!opts?.onBlockReply) return;
@@ -148,33 +187,34 @@ export async function handleInlineActions(params: {
       commandBodyNormalized: inlineCommand.command,
     };
     const inlineResult = await handleCommands({
-      ctx,
-      cfg,
-      command: inlineCommandContext,
-      agentId,
-      directives,
-      elevated: {
-        enabled: elevatedEnabled,
-        allowed: elevatedAllowed,
-        failures: elevatedFailures,
-      },
-      sessionEntry,
-      sessionStore,
-      sessionKey,
-      storePath,
-      sessionScope,
-      workspaceDir,
-      defaultGroupActivation: defaultActivation,
-      resolvedThinkLevel,
-      resolvedVerboseLevel: resolvedVerboseLevel ?? "off",
-      resolvedReasoningLevel,
-      resolvedElevatedLevel,
-      resolveDefaultThinkingLevel,
-      provider,
-      model,
-      contextTokens,
-      isGroup,
-    });
+    ctx,
+    cfg,
+    command: inlineCommandContext,
+    agentId,
+    directives,
+    elevated: {
+      enabled: elevatedEnabled,
+      allowed: elevatedAllowed,
+      failures: elevatedFailures,
+    },
+    sessionEntry,
+    sessionStore,
+    sessionKey,
+    storePath,
+    sessionScope,
+    workspaceDir,
+    defaultGroupActivation: defaultActivation,
+    resolvedThinkLevel,
+    resolvedVerboseLevel: resolvedVerboseLevel ?? "off",
+    resolvedReasoningLevel,
+    resolvedElevatedLevel,
+    resolveDefaultThinkingLevel,
+    provider,
+    model,
+    contextTokens,
+    isGroup,
+    skillCommands,
+  });
     if (inlineResult.reply) {
       if (!inlineCommand.cleaned) {
         typing.cleanup();
@@ -235,6 +275,7 @@ export async function handleInlineActions(params: {
     model,
     contextTokens,
     isGroup,
+    skillCommands,
   });
   if (!commandResult.shouldContinue) {
     typing.cleanup();

src/auto-reply/reply/get-reply.ts

@@ -203,6 +203,7 @@ export async function getReplyFromConfig(
     contextTokens,
     directiveAck,
     abortedLastRun,
+    skillFilter: opts?.skillFilter,
   });
   if (inlineActionResult.kind === "reply") {
     return inlineActionResult.reply;