docs(changelog): expand #1053 note

* fix: truncate skill command descriptions to 100 chars for Discord

Discord slash commands have a 100 character limit for descriptions.
Skill descriptions were not being truncated, causing command registration
to fail with an empty error from the Discord API.

* style: format

* style: format

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## 2026.1.15
+## 2026.1.16 (unreleased)
 
 ### Highlights
 - Plugins: add provider auth registry + `clawdbot models auth login` for plugin-driven OAuth/API key flows.
@@ -19,6 +19,7 @@
 - Repo: ignore local identity files to avoid accidental commits. (#1001) — thanks @gerardward2007.
 - Sessions/Security: add `session.dmScope` for multi-user DM isolation and audit warnings. (#948) — thanks @Alphonse-arianee.
 - Plugins: add provider auth registry + `clawdbot models auth login` for plugin-driven OAuth/API key flows.
+- Skills: add user-invocable skill commands with sanitized names and an opt-out for model invocation.
 - Onboarding: switch channels setup to a single-select loop with per-channel actions and disabled hints in the picker.
 - TUI: show provider/model labels for the active session and default model.
 - Heartbeat: add per-agent heartbeat configuration and multi-agent docs example.
@@ -47,6 +48,8 @@
 - Discord: allow emoji/sticker uploads + channel actions in config defaults. (#870) — thanks @JDIVE.
 
 ### Fixes
+- WhatsApp: default response prefix only for self-chat, using identity name when set.
+- Fix: make `clawdbot update` auto-update global installs when installed via a package manager.
 - Fix: list model picker entries as provider/model pairs for explicit selection. (#970) — thanks @mcinteerj.
 - Fix: align OpenAI image-gen defaults with DALL-E 3 standard quality and document output formats. (#880) — thanks @mkbehr.
 - Fix: persist `gateway.mode=local` after selecting Local run mode in `clawdbot configure`, even if no other sections are chosen.
@@ -58,6 +61,7 @@
 - Fix: refactor session store updates, add chat.inject, and harden subagent cleanup flow. (#944) — thanks @tyler6204.
 - Fix: clean up suspended CLI processes across backends. (#978) — thanks @Nachx639.
 - Fix: support MiniMax coding plan usage responses with `model_remains`/`current_interval_*` payloads.
+- Fix: honor message tool channel for duplicate suppression (prefer `NO_REPLY` after `message` tool sends). (#1053) — thanks @sashcatanzarite.
 - Fix: suppress WhatsApp pairing replies for historical catch-up DMs on initial link. (#904)
 - Browser: extension mode recovers when only one tab is attached (stale targetId fallback).
 - Browser: fix `tab not found` for extension relay snapshots/actions when Playwright blocks `newCDPSession` (use the single available Page).
@@ -67,6 +71,8 @@
 - Fix: normalize pairing CLI aliases, allow extension channels, and harden Zalo webhook payload parsing. (#991) — thanks @longmaba.
 - Fix: allow local Tailscale Serve hostnames without treating tailnet clients as direct. (#885) — thanks @oswalpalash.
 - Fix: reset sessions after role-ordering conflicts to recover from consecutive user turns. (#998)
+- Fix: keep background exec aborts from killing backgrounded sessions while honoring timeouts.
+- Discord: truncate skill command descriptions for slash command limits. (#1018) — thanks @evalexpr.
 
 ## 2026.1.14-1
 

docs/channels/whatsapp.md

@@ -82,15 +82,13 @@ When the wizard asks for your personal WhatsApp number, enter the phone you will
     "selfChatMode": true,
     "dmPolicy": "allowlist",
     "allowFrom": ["+15551234567"]
-  },
-  "messages": {
-    "responsePrefix": "[clawdbot]"
   }
 }
 ```
 
-Tip: set `messages.responsePrefix` explicitly if you want a consistent bot prefix
-on outbound replies.
+Self-chat replies default to `[{identity.name}]` when set (otherwise `[clawdbot]`)
+if `messages.responsePrefix` is unset. Set it explicitly to customize or disable
+the prefix (use `""` to remove it).
 
 ### Number sourcing tips
 - **Local eSIM** from your country's mobile carrier (most reliable)

docs/gateway/configuration.md

@@ -1271,7 +1271,9 @@ See [Messages](/concepts/messages) for queueing, sessions, and streaming context
 `responsePrefix` is applied to **all outbound replies** (tool summaries, block
 streaming, final replies) across channels unless already present.
 
-If `messages.responsePrefix` is unset, no prefix is applied by default.
+If `messages.responsePrefix` is unset, no prefix is applied by default. WhatsApp self-chat
+replies are the exception: they default to `[{identity.name}]` when set, otherwise
+`[clawdbot]`, so same-phone conversations stay legible.
 Set it to `"auto"` to derive `[{identity.name}]` for the routed agent (when set).
 
 #### Template variables

docs/tools/skills.md

@@ -80,6 +80,8 @@ Notes:
 - Use `{baseDir}` in instructions to reference the skill folder path.
 - Optional frontmatter keys:
   - `homepage` — URL surfaced as “Website” in the macOS Skills UI (also supported via `metadata.clawdbot.homepage`).
+  - `user-invocable` — `true|false` (default: `true`). When `true`, the skill is exposed as a user slash command.
+  - `disable-model-invocation` — `true|false` (default: `false`). When `true`, the skill is excluded from the model prompt (still available via user invocation).
 
 ## Gating (load-time filters)
 

docs/tools/slash-commands.md

@@ -96,6 +96,7 @@ Notes:
   - Example: `hey /status` triggers a status reply, and the remaining text continues through the normal flow.
   - Currently: `/help`, `/commands`, `/status` (`/usage`), `/whoami` (`/id`).
 - Unauthorized command-only messages are silently ignored, and inline `/...` tokens are treated as plain text.
+- **Skill commands:** `user-invocable` skills are exposed as slash commands. Names are sanitized to `a-z0-9_` (max 32 chars); collisions get numeric suffixes (e.g. `_2`).
 - **Native command arguments:** Discord uses autocomplete for dynamic options (and button menus when you omit required args). Telegram and Slack show a button menu when a command supports choices and you omit the arg.
 
 ## Usage vs cost (what shows where)

scripts/docker/install-sh-e2e/run.sh

@@ -323,38 +323,41 @@ run_profile() {
   local workspace="$3"
   local agent_model_provider="$4" # "openai"|"anthropic"
 
-  echo "==> Onboard ($profile)"
-  if [[ "$agent_model_provider" == "openai" ]]; then
-    clawdbot --profile "$profile" onboard \
-      --non-interactive \
-      --flow quickstart \
-      --auth-choice openai-api-key \
-      --openai-api-key "$OPENAI_API_KEY" \
-      --gateway-port "$port" \
+	  echo "==> Onboard ($profile)"
+	  if [[ "$agent_model_provider" == "openai" ]]; then
+	    clawdbot --profile "$profile" onboard \
+	      --non-interactive \
+	      --accept-risk \
+	      --flow quickstart \
+	      --auth-choice openai-api-key \
+	      --openai-api-key "$OPENAI_API_KEY" \
+	      --gateway-port "$port" \
+	      --gateway-bind loopback \
+      --gateway-auth token \
+      --workspace "$workspace" \
+      --skip-health
+	  elif [[ -n "$ANTHROPIC_API_TOKEN" ]]; then
+	    clawdbot --profile "$profile" onboard \
+	      --non-interactive \
+	      --accept-risk \
+	      --flow quickstart \
+	      --auth-choice token \
+	      --token-provider anthropic \
+	      --token "$ANTHROPIC_API_TOKEN" \
+	      --gateway-port "$port" \
       --gateway-bind loopback \
       --gateway-auth token \
       --workspace "$workspace" \
       --skip-health
-  elif [[ -n "$ANTHROPIC_API_TOKEN" ]]; then
-    clawdbot --profile "$profile" onboard \
-      --non-interactive \
-      --flow quickstart \
-      --auth-choice token \
-      --token-provider anthropic \
-      --token "$ANTHROPIC_API_TOKEN" \
-      --gateway-port "$port" \
-      --gateway-bind loopback \
-      --gateway-auth token \
-      --workspace "$workspace" \
-      --skip-health
-  else
-    clawdbot --profile "$profile" onboard \
-      --non-interactive \
-      --flow quickstart \
-      --auth-choice apiKey \
-      --anthropic-api-key "$ANTHROPIC_API_KEY" \
-      --gateway-port "$port" \
-      --gateway-bind loopback \
+	  else
+	    clawdbot --profile "$profile" onboard \
+	      --non-interactive \
+	      --accept-risk \
+	      --flow quickstart \
+	      --auth-choice apiKey \
+	      --anthropic-api-key "$ANTHROPIC_API_KEY" \
+	      --gateway-port "$port" \
+	      --gateway-bind loopback \
       --gateway-auth token \
       --workspace "$workspace" \
       --skip-health

scripts/e2e/doctor-install-switch-docker.sh

@@ -69,15 +69,20 @@ if [[ "$*" == *"enable-linger"* ]]; then
 fi
 exit 0
 LOGINCTL
-	  chmod +x /tmp/clawdbot-bin/loginctl
-	
-	  # Install the npm-global variant from the local /app source.
-	  pkg_tgz="$(npm pack --silent /app)"
-	  npm install -g --prefix /tmp/npm-prefix "/app/$pkg_tgz"
-	
-	  npm_bin="/tmp/npm-prefix/bin/clawdbot"
-	  npm_entry="/tmp/npm-prefix/lib/node_modules/clawdbot/dist/entry.js"
-	  git_entry="/app/dist/entry.js"
+  chmod +x /tmp/clawdbot-bin/loginctl
+
+  # Install the npm-global variant from the local /app source.
+  # `npm pack` can emit script output; keep only the tarball name.
+  pkg_tgz="$(npm pack --silent /app | tail -n 1 | tr -d '\r')"
+  if [ ! -f "/app/$pkg_tgz" ]; then
+    echo "npm pack failed (expected /app/$pkg_tgz)"
+    exit 1
+  fi
+  npm install -g --prefix /tmp/npm-prefix "/app/$pkg_tgz"
+
+  npm_bin="/tmp/npm-prefix/bin/clawdbot"
+  npm_entry="/tmp/npm-prefix/lib/node_modules/clawdbot/dist/entry.js"
+  git_entry="/app/dist/entry.js"
 
   assert_entrypoint() {
     local unit_path="$1"
@@ -126,17 +131,17 @@ LOGINCTL
     assert_entrypoint "$unit_path" "$doctor_expected"
   }
 
-	  run_flow \
-	    "npm-to-git" \
-	    "$npm_bin daemon install --force" \
-	    "$npm_entry" \
-	    "node $git_entry doctor --repair --force" \
-	    "$git_entry"
+  run_flow \
+    "npm-to-git" \
+    "$npm_bin daemon install --force" \
+    "$npm_entry" \
+    "node $git_entry doctor --repair --force" \
+    "$git_entry"
 
-	  run_flow \
-	    "git-to-npm" \
-	    "node $git_entry daemon install --force" \
-	    "$git_entry" \
-	    "$npm_bin doctor --repair --force" \
-	    "$npm_entry"
+  run_flow \
+    "git-to-npm" \
+    "node $git_entry daemon install --force" \
+    "$git_entry" \
+    "$npm_bin doctor --repair --force" \
+    "$npm_entry"
 '

scripts/e2e/onboard-docker.sh

@@ -42,6 +42,38 @@ TRASH
     printf "%b" "$payload" >&3 2>/dev/null || true
   }
 
+  wait_for_log() {
+    local needle="$1"
+    local timeout_s="${2:-45}"
+    local needle_compact
+    needle_compact="$(printf "%s" "$needle" | sed -E "s/[[:space:]]+//g")"
+    local start_s
+    start_s="$(date +%s)"
+    while true; do
+      if [ -n "${WIZARD_LOG_PATH:-}" ] && [ -f "$WIZARD_LOG_PATH" ]; then
+        if NEEDLE="$needle_compact" node --input-type=module -e "
+          import fs from \"node:fs\";
+          const file = process.env.WIZARD_LOG_PATH;
+          const needle = process.env.NEEDLE ?? \"\";
+          let text = \"\";
+          try { text = fs.readFileSync(file, \"utf8\"); } catch { process.exit(1); }
+          text = text.replace(/\\x1b\\[[0-9;]*[A-Za-z]/g, \"\").replace(/\\s+/g, \"\");
+          process.exit(text.includes(needle) ? 0 : 1);
+        "; then
+          return 0
+        fi
+      fi
+      if [ $(( $(date +%s) - start_s )) -ge "$timeout_s" ]; then
+        echo "Timeout waiting for log: $needle"
+        if [ -n "${WIZARD_LOG_PATH:-}" ] && [ -f "$WIZARD_LOG_PATH" ]; then
+          tail -n 140 "$WIZARD_LOG_PATH" || true
+        fi
+        return 1
+      fi
+      sleep 0.2
+    done
+  }
+
   start_gateway() {
     node dist/index.js gateway --port 18789 --bind loopback --allow-unconfigured > /tmp/gateway-e2e.log 2>&1 &
     GATEWAY_PID="$!"
@@ -81,6 +113,8 @@ TRASH
     input_fifo="$(mktemp -u "/tmp/clawdbot-onboard-${case_name}.XXXXXX")"
     mkfifo "$input_fifo"
     local log_path="/tmp/clawdbot-onboard-${case_name}.log"
+    WIZARD_LOG_PATH="$log_path"
+    export WIZARD_LOG_PATH
     # Run under script to keep an interactive TTY for clack prompts.
     script -q -c "$command" "$log_path" < "$input_fifo" &
     wizard_pid=$!
@@ -135,36 +169,44 @@ TRASH
   }
 
   send_local_basic() {
+    # Risk acknowledgement (default is "No").
+    send $'"'"'y\r'"'"' 0.6
     # Choose local gateway, accept defaults, skip channels/skills/daemon, skip UI.
     send $'"'"'\r'"'"' 0.5
   }
 
-  send_reset_config_only() {
-    # Reset config + reuse the local defaults flow.
-    send $'"'"'\e[B'"'"' 0.3
-    send $'"'"'\e[B'"'"' 0.3
-    send $'"'"'\r'"'"' 0.4
-    send $'"'"'\r'"'"' 0.4
-    send "" 1.2
-    send_local_basic
-  }
+	  send_reset_config_only() {
+	    # Risk acknowledgement (default is "No").
+	    send $'"'"'y\r'"'"' 0.8
+	    # Reset config + reuse the local defaults flow.
+	    send $'"'"'\e[B'"'"' 0.3
+	    send $'"'"'\e[B'"'"' 0.3
+	    send $'"'"'\r'"'"' 0.4
+	    send $'"'"'\r'"'"' 0.4
+	    send "" 1.2
+	    send_local_basic
+	  }
 
   send_channels_flow() {
     # Configure channels via configure wizard.
-    send $'"'"'\r'"'"' 1.0
-    send "" 1.5
-    # Mode (default Configure channels)
-    send $'"'"'\r'"'"' 0.8
-    send "" 1.0
-    # Configure chat channels now? -> No
-    send $'"'"'n\r'"'"' 0.6
+    # Prompts are interactive; notes are not. Use conservative delays to stay in sync.
+    # Where will the Gateway run? -> Local (default)
+    send $'"'"'\r'"'"' 1.2
+    # Channels mode -> Configure/link (default)
+    send $'"'"'\r'"'"' 1.5
+    # Select a channel -> Finished (last option; clack wraps on Up)
+    send $'"'"'\e[A\r'"'"' 2.0
+    # Keep stdin open until wizard exits.
+    send "" 2.5
   }
 
   send_skills_flow() {
     # Select skills section and skip optional installs.
-    send $'"'"'\r'"'"' 1.0
-    send "" 1.2
-    send $'"'"'n\r'"'"' 0.6
+    send $'"'"'\r'"'"' 1.2
+    send "" 1.0
+    # Configure skills now? -> No
+    send $'"'"'n\r'"'"' 1.2
+    send "" 2.0
   }
 
   run_case_local_basic() {
@@ -257,7 +299,7 @@ NODE
     export HOME="$home_dir"
     mkdir -p "$HOME"
     # Smoke test non-interactive remote config write.
-    node dist/index.js onboard --non-interactive \
+    node dist/index.js onboard --non-interactive --accept-risk \
       --mode remote \
       --remote-url ws://gateway.local:18789 \
       --remote-token remote-token \

src/agents/bash-tools.exec.background-abort.test.ts

@@ -8,6 +8,8 @@ import {
 } from "./bash-process-registry";
 import { killProcessTree } from "./shell-utils";
 
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
 afterEach(() => {
   resetProcessRegistryForTests();
 });
@@ -27,7 +29,7 @@ test("background exec is not killed when tool signal aborts", async () => {
 
   abortController.abort();
 
-  await new Promise((resolve) => setTimeout(resolve, 150));
+  await sleep(150);
 
   const running = getSession(sessionId);
   const finished = getFinishedSession(sessionId);
@@ -40,3 +42,97 @@ test("background exec is not killed when tool signal aborts", async () => {
     if (pid) killProcessTree(pid);
   }
 });
+
+test("background exec still times out after tool signal abort", async () => {
+  const tool = createExecTool({ allowBackground: true, backgroundMs: 0 });
+  const abortController = new AbortController();
+
+  const result = await tool.execute(
+    "toolcall",
+    {
+      command: 'node -e "setTimeout(() => {}, 5000)"',
+      background: true,
+      timeout: 0.2,
+    },
+    abortController.signal,
+  );
+
+  expect(result.details.status).toBe("running");
+  const sessionId = (result.details as { sessionId: string }).sessionId;
+
+  abortController.abort();
+
+  let finished = getFinishedSession(sessionId);
+  const deadline = Date.now() + 2000;
+  while (!finished && Date.now() < deadline) {
+    await sleep(20);
+    finished = getFinishedSession(sessionId);
+  }
+
+  const running = getSession(sessionId);
+
+  try {
+    expect(finished?.status).toBe("failed");
+  } finally {
+    const pid = running?.pid;
+    if (pid) killProcessTree(pid);
+  }
+});
+
+test("yielded background exec is not killed when tool signal aborts", async () => {
+  const tool = createExecTool({ allowBackground: true, backgroundMs: 10 });
+  const abortController = new AbortController();
+
+  const result = await tool.execute(
+    "toolcall",
+    { command: 'node -e "setTimeout(() => {}, 5000)"', yieldMs: 5 },
+    abortController.signal,
+  );
+
+  expect(result.details.status).toBe("running");
+  const sessionId = (result.details as { sessionId: string }).sessionId;
+
+  abortController.abort();
+
+  await sleep(150);
+
+  const running = getSession(sessionId);
+  const finished = getFinishedSession(sessionId);
+
+  try {
+    expect(finished).toBeUndefined();
+    expect(running?.exited).toBe(false);
+  } finally {
+    const pid = running?.pid;
+    if (pid) killProcessTree(pid);
+  }
+});
+
+test("yielded background exec still times out", async () => {
+  const tool = createExecTool({ allowBackground: true, backgroundMs: 10 });
+
+  const result = await tool.execute("toolcall", {
+    command: 'node -e "setTimeout(() => {}, 5000)"',
+    yieldMs: 5,
+    timeout: 0.2,
+  });
+
+  expect(result.details.status).toBe("running");
+  const sessionId = (result.details as { sessionId: string }).sessionId;
+
+  let finished = getFinishedSession(sessionId);
+  const deadline = Date.now() + 2000;
+  while (!finished && Date.now() < deadline) {
+    await sleep(20);
+    finished = getFinishedSession(sessionId);
+  }
+
+  const running = getSession(sessionId);
+
+  try {
+    expect(finished?.status).toBe("failed");
+  } finally {
+    const pid = running?.pid;
+    if (pid) killProcessTree(pid);
+  }
+});

src/agents/bash-tools.exec.ts

@@ -262,22 +262,28 @@ export function createExecTool(
         fn();
       };
 
-      const onAbort = () => {
+      // Tool-call abort should not kill backgrounded sessions; timeouts still must.
+      const onAbortSignal = () => {
         if (yielded || session.backgrounded) return;
         killSession(session);
       };
 
-      if (signal?.aborted) onAbort();
+      // Timeouts always terminate, even for backgrounded sessions.
+      const onTimeout = () => {
+        timedOut = true;
+        killSession(session);
+      };
+
+      if (signal?.aborted) onAbortSignal();
       else if (signal) {
-        signal.addEventListener("abort", onAbort, { once: true });
+        signal.addEventListener("abort", onAbortSignal, { once: true });
       }
 
       const effectiveTimeout =
         typeof params.timeout === "number" ? params.timeout : defaultTimeoutSec;
       if (effectiveTimeout > 0) {
         timeoutTimer = setTimeout(() => {
-          timedOut = true;
-          onAbort();
+          onTimeout();
         }, effectiveTimeout * 1000);
       }
 

src/agents/models.profiles.live.test.ts

@@ -62,6 +62,11 @@ function isModelNotFoundErrorMessage(raw: string): boolean {
   return false;
 }
 
+function isChatGPTUsageLimitErrorMessage(raw: string): boolean {
+  const msg = raw.toLowerCase();
+  return msg.includes("hit your chatgpt usage limit") && msg.includes("try again in");
+}
+
 function toInt(value: string | undefined, fallback: number): number {
   const trimmed = value?.trim();
   if (!trimmed) return fallback;
@@ -371,6 +376,18 @@ describeLive("live models (profile keys)", () => {
               logProgress(`${progressLabel}: skip (empty response)`);
               break;
             }
+            if (
+              ok.text.length === 0 &&
+              allowNotFoundSkip &&
+              (model.provider === "google-antigravity" || model.provider === "openai-codex")
+            ) {
+              skipped.push({
+                model: id,
+                reason: "no text returned (provider returned empty content)",
+              });
+              logProgress(`${progressLabel}: skip (empty response)`);
+              break;
+            }
             expect(ok.text.length).toBeGreaterThan(0);
             logProgress(`${progressLabel}: done`);
             break;
@@ -416,6 +433,15 @@ describeLive("live models (profile keys)", () => {
               logProgress(`${progressLabel}: skip (rate limit)`);
               break;
             }
+            if (
+              allowNotFoundSkip &&
+              model.provider === "openai-codex" &&
+              isChatGPTUsageLimitErrorMessage(message)
+            ) {
+              skipped.push({ model: id, reason: message });
+              logProgress(`${progressLabel}: skip (chatgpt usage limit)`);
+              break;
+            }
             logProgress(`${progressLabel}: failed`);
             failures.push({ model: id, error: message });
             break;

src/agents/pi-embedded-subscribe.tools.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, it } from "vitest";
+
+import { extractMessagingToolSend } from "./pi-embedded-subscribe.tools.js";
+
+describe("extractMessagingToolSend", () => {
+  it("uses channel as provider for message tool", () => {
+    const result = extractMessagingToolSend("message", {
+      action: "send",
+      channel: "telegram",
+      to: "123",
+    });
+
+    expect(result?.tool).toBe("message");
+    expect(result?.provider).toBe("telegram");
+    expect(result?.to).toBe("telegram:123");
+  });
+
+  it("prefers provider when both provider and channel are set", () => {
+    const result = extractMessagingToolSend("message", {
+      action: "send",
+      provider: "slack",
+      channel: "telegram",
+      to: "channel:C1",
+    });
+
+    expect(result?.tool).toBe("message");
+    expect(result?.provider).toBe("slack");
+    expect(result?.to).toBe("channel:c1");
+  });
+});

src/agents/pi-embedded-subscribe.tools.ts

@@ -57,8 +57,10 @@ export function extractMessagingToolSend(
     const toRaw = typeof args.to === "string" ? args.to : undefined;
     if (!toRaw) return undefined;
     const providerRaw = typeof args.provider === "string" ? args.provider.trim() : "";
-    const providerId = providerRaw ? normalizeChannelId(providerRaw) : null;
-    const provider = providerId ?? (providerRaw ? providerRaw.toLowerCase() : "message");
+    const channelRaw = typeof args.channel === "string" ? args.channel.trim() : "";
+    const providerHint = providerRaw || channelRaw;
+    const providerId = providerHint ? normalizeChannelId(providerHint) : null;
+    const provider = providerId ?? (providerHint ? providerHint.toLowerCase() : "message");
     const to = normalizeTargetForProvider(provider, toRaw);
     return to ? { tool: toolName, provider, accountId, to } : undefined;
   }

src/agents/skills.buildworkspaceskillcommands.test.ts

@@ -0,0 +1,92 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { buildWorkspaceSkillCommandSpecs } from "./skills.js";
+
+async function writeSkill(params: {
+  dir: string;
+  name: string;
+  description: string;
+  frontmatterExtra?: string;
+}) {
+  const { dir, name, description, frontmatterExtra } = params;
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(
+    path.join(dir, "SKILL.md"),
+    `---
+name: ${name}
+description: ${description}
+${frontmatterExtra ?? ""}
+---
+
+# ${name}
+`,
+    "utf-8",
+  );
+}
+
+describe("buildWorkspaceSkillCommandSpecs", () => {
+  it("sanitizes and de-duplicates command names", async () => {
+    const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-"));
+    await writeSkill({
+      dir: path.join(workspaceDir, "skills", "hello-world"),
+      name: "hello-world",
+      description: "Hello world skill",
+    });
+    await writeSkill({
+      dir: path.join(workspaceDir, "skills", "hello_world"),
+      name: "hello_world",
+      description: "Hello underscore skill",
+    });
+    await writeSkill({
+      dir: path.join(workspaceDir, "skills", "help"),
+      name: "help",
+      description: "Help skill",
+    });
+    await writeSkill({
+      dir: path.join(workspaceDir, "skills", "hidden"),
+      name: "hidden-skill",
+      description: "Hidden skill",
+      frontmatterExtra: "user-invocable: false",
+    });
+
+    const commands = buildWorkspaceSkillCommandSpecs(workspaceDir, {
+      managedSkillsDir: path.join(workspaceDir, ".managed"),
+      bundledSkillsDir: path.join(workspaceDir, ".bundled"),
+      reservedNames: new Set(["help"]),
+    });
+
+    const names = commands.map((entry) => entry.name).sort();
+    expect(names).toEqual(["hello_world", "hello_world_2", "help_2"]);
+    expect(commands.find((entry) => entry.skillName === "hidden-skill")).toBeUndefined();
+  });
+
+  it("truncates descriptions longer than 100 characters for Discord compatibility", async () => {
+    const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-"));
+    const longDescription =
+      "This is a very long description that exceeds Discord's 100 character limit for slash command descriptions and should be truncated";
+    await writeSkill({
+      dir: path.join(workspaceDir, "skills", "long-desc"),
+      name: "long-desc",
+      description: longDescription,
+    });
+    await writeSkill({
+      dir: path.join(workspaceDir, "skills", "short-desc"),
+      name: "short-desc",
+      description: "Short description",
+    });
+
+    const commands = buildWorkspaceSkillCommandSpecs(workspaceDir, {
+      managedSkillsDir: path.join(workspaceDir, ".managed"),
+      bundledSkillsDir: path.join(workspaceDir, ".bundled"),
+    });
+
+    const longCmd = commands.find((entry) => entry.skillName === "long-desc");
+    const shortCmd = commands.find((entry) => entry.skillName === "short-desc");
+
+    expect(longCmd?.description.length).toBeLessThanOrEqual(100);
+    expect(longCmd?.description.endsWith("…")).toBe(true);
+    expect(shortCmd?.description).toBe("Short description");
+  });
+});

src/agents/skills.buildworkspaceskillsnapshot.test.ts

@@ -9,15 +9,17 @@ async function _writeSkill(params: {
   name: string;
   description: string;
   metadata?: string;
+  frontmatterExtra?: string;
   body?: string;
 }) {
-  const { dir, name, description, metadata, body } = params;
+  const { dir, name, description, metadata, frontmatterExtra, body } = params;
   await fs.mkdir(dir, { recursive: true });
   await fs.writeFile(
     path.join(dir, "SKILL.md"),
     `---
 name: ${name}
 description: ${description}${metadata ? `\nmetadata: ${metadata}` : ""}
+${frontmatterExtra ?? ""}
 ---
 
 ${body ?? `# ${name}\n`}
@@ -38,4 +40,31 @@ describe("buildWorkspaceSkillSnapshot", () => {
     expect(snapshot.prompt).toBe("");
     expect(snapshot.skills).toEqual([]);
   });
+
+  it("omits disable-model-invocation skills from the prompt", async () => {
+    const workspaceDir = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-"));
+    await _writeSkill({
+      dir: path.join(workspaceDir, "skills", "visible-skill"),
+      name: "visible-skill",
+      description: "Visible skill",
+    });
+    await _writeSkill({
+      dir: path.join(workspaceDir, "skills", "hidden-skill"),
+      name: "hidden-skill",
+      description: "Hidden skill",
+      frontmatterExtra: "disable-model-invocation: true",
+    });
+
+    const snapshot = buildWorkspaceSkillSnapshot(workspaceDir, {
+      managedSkillsDir: path.join(workspaceDir, ".managed"),
+      bundledSkillsDir: path.join(workspaceDir, ".bundled"),
+    });
+
+    expect(snapshot.prompt).toContain("visible-skill");
+    expect(snapshot.prompt).not.toContain("hidden-skill");
+    expect(snapshot.skills.map((skill) => skill.name).sort()).toEqual([
+      "hidden-skill",
+      "visible-skill",
+    ]);
+  });
 });

src/agents/skills.ts

@@ -16,6 +16,7 @@ export {
 export type {
   ClawdbotSkillMetadata,
   SkillEligibilityContext,
+  SkillCommandSpec,
   SkillEntry,
   SkillInstallSpec,
   SkillSnapshot,
@@ -24,6 +25,7 @@ export type {
 export {
   buildWorkspaceSkillSnapshot,
   buildWorkspaceSkillsPrompt,
+  buildWorkspaceSkillCommandSpecs,
   filterWorkspaceSkillEntries,
   loadWorkspaceSkillEntries,
   resolveSkillsPromptForRun,

src/agents/skills/frontmatter.ts

@@ -5,6 +5,7 @@ import type {
   ParsedSkillFrontmatter,
   SkillEntry,
   SkillInstallSpec,
+  SkillInvocationPolicy,
 } from "./types.js";
 
 function stripQuotes(value: string): string {
@@ -79,6 +80,19 @@ function getFrontmatterValue(frontmatter: ParsedSkillFrontmatter, key: string):
   return typeof raw === "string" ? raw : undefined;
 }
 
+function parseFrontmatterBool(value: string | undefined, fallback: boolean): boolean {
+  if (!value) return fallback;
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return fallback;
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "on") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "off") {
+    return false;
+  }
+  return fallback;
+}
+
 export function resolveClawdbotMetadata(
   frontmatter: ParsedSkillFrontmatter,
 ): ClawdbotSkillMetadata | undefined {
@@ -121,6 +135,18 @@ export function resolveClawdbotMetadata(
   }
 }
 
+export function resolveSkillInvocationPolicy(
+  frontmatter: ParsedSkillFrontmatter,
+): SkillInvocationPolicy {
+  return {
+    userInvocable: parseFrontmatterBool(getFrontmatterValue(frontmatter, "user-invocable"), true),
+    disableModelInvocation: parseFrontmatterBool(
+      getFrontmatterValue(frontmatter, "disable-model-invocation"),
+      false,
+    ),
+  };
+}
+
 export function resolveSkillKey(skill: Skill, entry?: SkillEntry): string {
   return entry?.clawdbot?.skillKey ?? skill.name;
 }

src/agents/skills/types.ts

@@ -26,6 +26,17 @@ export type ClawdbotSkillMetadata = {
   install?: SkillInstallSpec[];
 };
 
+export type SkillInvocationPolicy = {
+  userInvocable: boolean;
+  disableModelInvocation: boolean;
+};
+
+export type SkillCommandSpec = {
+  name: string;
+  skillName: string;
+  description: string;
+};
+
 export type SkillsInstallPreferences = {
   preferBrew: boolean;
   nodeManager: "npm" | "pnpm" | "yarn" | "bun";
@@ -37,6 +48,7 @@ export type SkillEntry = {
   skill: Skill;
   frontmatter: ParsedSkillFrontmatter;
   clawdbot?: ClawdbotSkillMetadata;
+  invocation?: SkillInvocationPolicy;
 };
 
 export type SkillEligibilityContext = {

src/agents/skills/workspace.ts

@@ -11,11 +11,16 @@ import type { ClawdbotConfig } from "../../config/config.js";
 import { CONFIG_DIR, resolveUserPath } from "../../utils.js";
 import { resolveBundledSkillsDir } from "./bundled-dir.js";
 import { shouldIncludeSkill } from "./config.js";
-import { parseFrontmatter, resolveClawdbotMetadata } from "./frontmatter.js";
+import {
+  parseFrontmatter,
+  resolveClawdbotMetadata,
+  resolveSkillInvocationPolicy,
+} from "./frontmatter.js";
 import { serializeByKey } from "./serialize.js";
 import type {
   ParsedSkillFrontmatter,
   SkillEligibilityContext,
+  SkillCommandSpec,
   SkillEntry,
   SkillSnapshot,
 } from "./types.js";
@@ -43,6 +48,36 @@ function filterSkillEntries(
   return filtered;
 }
 
+const SKILL_COMMAND_MAX_LENGTH = 32;
+const SKILL_COMMAND_FALLBACK = "skill";
+// Discord command descriptions must be ≤100 characters
+const SKILL_COMMAND_DESCRIPTION_MAX_LENGTH = 100;
+
+function sanitizeSkillCommandName(raw: string): string {
+  const normalized = raw
+    .toLowerCase()
+    .replace(/[^a-z0-9_]+/g, "_")
+    .replace(/_+/g, "_")
+    .replace(/^_+|_+$/g, "");
+  const trimmed = normalized.slice(0, SKILL_COMMAND_MAX_LENGTH);
+  return trimmed || SKILL_COMMAND_FALLBACK;
+}
+
+function resolveUniqueSkillCommandName(base: string, used: Set<string>): string {
+  const normalizedBase = base.toLowerCase();
+  if (!used.has(normalizedBase)) return base;
+  for (let index = 2; index < 1000; index += 1) {
+    const suffix = `_${index}`;
+    const maxBaseLength = Math.max(1, SKILL_COMMAND_MAX_LENGTH - suffix.length);
+    const trimmedBase = base.slice(0, maxBaseLength);
+    const candidate = `${trimmedBase}${suffix}`;
+    const candidateKey = candidate.toLowerCase();
+    if (!used.has(candidateKey)) return candidate;
+  }
+  const fallback = `${base.slice(0, Math.max(1, SKILL_COMMAND_MAX_LENGTH - 2))}_x`;
+  return fallback;
+}
+
 function loadSkillEntries(
   workspaceDir: string,
   opts?: {
@@ -114,6 +149,7 @@ function loadSkillEntries(
       skill,
       frontmatter,
       clawdbot: resolveClawdbotMetadata(frontmatter),
+      invocation: resolveSkillInvocationPolicy(frontmatter),
     };
   });
   return skillEntries;
@@ -139,7 +175,10 @@ export function buildWorkspaceSkillSnapshot(
     opts?.skillFilter,
     opts?.eligibility,
   );
-  const resolvedSkills = eligible.map((entry) => entry.skill);
+  const promptEntries = eligible.filter(
+    (entry) => entry.invocation?.disableModelInvocation !== true,
+  );
+  const resolvedSkills = promptEntries.map((entry) => entry.skill);
   const remoteNote = opts?.eligibility?.remote?.note?.trim();
   const prompt = [remoteNote, formatSkillsForPrompt(resolvedSkills)].filter(Boolean).join("\n");
   return {
@@ -172,8 +211,11 @@ export function buildWorkspaceSkillsPrompt(
     opts?.skillFilter,
     opts?.eligibility,
   );
+  const promptEntries = eligible.filter(
+    (entry) => entry.invocation?.disableModelInvocation !== true,
+  );
   const remoteNote = opts?.eligibility?.remote?.note?.trim();
-  return [remoteNote, formatSkillsForPrompt(eligible.map((entry) => entry.skill))]
+  return [remoteNote, formatSkillsForPrompt(promptEntries.map((entry) => entry.skill))]
     .filter(Boolean)
     .join("\n");
 }
@@ -251,3 +293,47 @@ export function filterWorkspaceSkillEntries(
 ): SkillEntry[] {
   return filterSkillEntries(entries, config);
 }
+
+export function buildWorkspaceSkillCommandSpecs(
+  workspaceDir: string,
+  opts?: {
+    config?: ClawdbotConfig;
+    managedSkillsDir?: string;
+    bundledSkillsDir?: string;
+    entries?: SkillEntry[];
+    skillFilter?: string[];
+    eligibility?: SkillEligibilityContext;
+    reservedNames?: Set<string>;
+  },
+): SkillCommandSpec[] {
+  const skillEntries = opts?.entries ?? loadSkillEntries(workspaceDir, opts);
+  const eligible = filterSkillEntries(
+    skillEntries,
+    opts?.config,
+    opts?.skillFilter,
+    opts?.eligibility,
+  );
+  const userInvocable = eligible.filter((entry) => entry.invocation?.userInvocable !== false);
+  const used = new Set<string>();
+  for (const reserved of opts?.reservedNames ?? []) {
+    used.add(reserved.toLowerCase());
+  }
+
+  const specs: SkillCommandSpec[] = [];
+  for (const entry of userInvocable) {
+    const base = sanitizeSkillCommandName(entry.skill.name);
+    const unique = resolveUniqueSkillCommandName(base, used);
+    used.add(unique.toLowerCase());
+    const rawDescription = entry.skill.description?.trim() || entry.skill.name;
+    const description =
+      rawDescription.length > SKILL_COMMAND_DESCRIPTION_MAX_LENGTH
+        ? rawDescription.slice(0, SKILL_COMMAND_DESCRIPTION_MAX_LENGTH - 1) + "…"
+        : rawDescription;
+    specs.push({
+      name: unique,
+      skillName: entry.skill.name,
+      description,
+    });
+  }
+  return specs;
+}

src/agents/system-prompt.test.ts

@@ -216,6 +216,7 @@ describe("buildAgentSystemPrompt", () => {
 
     expect(prompt).toContain("message: Send messages and channel actions");
     expect(prompt).toContain("### message tool");
+    expect(prompt).toContain("respond with ONLY: NO_REPLY");
   });
 
   it("includes runtime provider capabilities when present", () => {

src/agents/system-prompt.ts

@@ -95,6 +95,7 @@ function buildMessagingSection(params: {
           "- Use `message` for proactive sends + channel actions (polls, reactions, etc.).",
           "- For `action=send`, include `to` and `message`.",
           `- If multiple channels are configured, pass \`channel\` (${params.messageChannelOptions}).`,
+          `- If you use \`message\` (\`action=send\`) to deliver your user-visible reply, respond with ONLY: ${SILENT_REPLY_TOKEN} (avoid duplicate replies).`,
           params.inlineButtonsEnabled
             ? "- Inline buttons supported. Use `action=send` with `buttons=[[{text,callback_data}]]` (callback_data routes back as a user message)."
             : params.runtimeChannel

src/auto-reply/commands-registry.test.ts

@@ -45,6 +45,29 @@ describe("commands registry", () => {
     expect(nativeDisabled.find((spec) => spec.name === "debug")).toBeFalsy();
   });
 
+  it("appends skill commands when provided", () => {
+    const skillCommands = [
+      {
+        name: "demo_skill",
+        skillName: "demo-skill",
+        description: "Demo skill",
+      },
+    ];
+    const commands = listChatCommandsForConfig(
+      {
+        commands: { config: false, debug: false },
+      },
+      { skillCommands },
+    );
+    expect(commands.find((spec) => spec.nativeName === "demo_skill")).toBeTruthy();
+
+    const native = listNativeCommandSpecsForConfig(
+      { commands: { config: false, debug: false, native: true } },
+      { skillCommands },
+    );
+    expect(native.find((spec) => spec.name === "demo_skill")).toBeTruthy();
+  });
+
   it("detects known text commands", () => {
     const detection = getCommandDetection();
     expect(detection.exact.has("/commands")).toBe(true);

src/auto-reply/commands-registry.ts

@@ -1,4 +1,5 @@
 import type { ClawdbotConfig } from "../config/types.js";
+import type { SkillCommandSpec } from "../agents/skills.js";
 import { CHAT_COMMANDS, getNativeCommandSurfaces } from "./commands-registry.data.js";
 import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../agents/defaults.js";
 import { resolveConfiguredModelRef } from "../agents/model-selection.js";
@@ -61,8 +62,24 @@ function escapeRegExp(value: string) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-export function listChatCommands(): ChatCommandDefinition[] {
-  return [...CHAT_COMMANDS];
+function buildSkillCommandDefinitions(skillCommands?: SkillCommandSpec[]): ChatCommandDefinition[] {
+  if (!skillCommands || skillCommands.length === 0) return [];
+  return skillCommands.map((spec) => ({
+    key: `skill:${spec.skillName}`,
+    nativeName: spec.name,
+    description: spec.description,
+    textAliases: [`/${spec.name}`],
+    acceptsArgs: true,
+    argsParsing: "none",
+    scope: "both",
+  }));
+}
+
+export function listChatCommands(params?: {
+  skillCommands?: SkillCommandSpec[];
+}): ChatCommandDefinition[] {
+  if (!params?.skillCommands?.length) return [...CHAT_COMMANDS];
+  return [...CHAT_COMMANDS, ...buildSkillCommandDefinitions(params.skillCommands)];
 }
 
 export function isCommandEnabled(cfg: ClawdbotConfig, commandKey: string): boolean {
@@ -72,23 +89,33 @@ export function isCommandEnabled(cfg: ClawdbotConfig, commandKey: string): boole
   return true;
 }
 
-export function listChatCommandsForConfig(cfg: ClawdbotConfig): ChatCommandDefinition[] {
-  return CHAT_COMMANDS.filter((command) => isCommandEnabled(cfg, command.key));
+export function listChatCommandsForConfig(
+  cfg: ClawdbotConfig,
+  params?: { skillCommands?: SkillCommandSpec[] },
+): ChatCommandDefinition[] {
+  const base = CHAT_COMMANDS.filter((command) => isCommandEnabled(cfg, command.key));
+  if (!params?.skillCommands?.length) return base;
+  return [...base, ...buildSkillCommandDefinitions(params.skillCommands)];
 }
 
-export function listNativeCommandSpecs(): NativeCommandSpec[] {
-  return CHAT_COMMANDS.filter((command) => command.scope !== "text" && command.nativeName).map(
-    (command) => ({
+export function listNativeCommandSpecs(params?: {
+  skillCommands?: SkillCommandSpec[];
+}): NativeCommandSpec[] {
+  return listChatCommands({ skillCommands: params?.skillCommands })
+    .filter((command) => command.scope !== "text" && command.nativeName)
+    .map((command) => ({
       name: command.nativeName ?? command.key,
       description: command.description,
       acceptsArgs: Boolean(command.acceptsArgs),
       args: command.args,
-    }),
-  );
+    }));
 }
 
-export function listNativeCommandSpecsForConfig(cfg: ClawdbotConfig): NativeCommandSpec[] {
-  return listChatCommandsForConfig(cfg)
+export function listNativeCommandSpecsForConfig(
+  cfg: ClawdbotConfig,
+  params?: { skillCommands?: SkillCommandSpec[] },
+): NativeCommandSpec[] {
+  return listChatCommandsForConfig(cfg, params)
     .filter((command) => command.scope !== "text" && command.nativeName)
     .map((command) => ({
       name: command.nativeName ?? command.key,

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;
@@ -174,6 +213,7 @@ export async function handleInlineActions(params: {
       model,
       contextTokens,
       isGroup,
+      skillCommands,
     });
     if (inlineResult.reply) {
       if (!inlineCommand.cleaned) {
@@ -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;

src/auto-reply/skill-commands.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it } from "vitest";
+import { resolveSkillCommandInvocation } from "./skill-commands.js";
+
+describe("resolveSkillCommandInvocation", () => {
+  it("matches skill commands and parses args", () => {
+    const invocation = resolveSkillCommandInvocation({
+      commandBodyNormalized: "/demo_skill do the thing",
+      skillCommands: [{ name: "demo_skill", skillName: "demo-skill", description: "Demo" }],
+    });
+    expect(invocation?.command.skillName).toBe("demo-skill");
+    expect(invocation?.args).toBe("do the thing");
+  });
+
+  it("returns null for unknown commands", () => {
+    const invocation = resolveSkillCommandInvocation({
+      commandBodyNormalized: "/unknown arg",
+      skillCommands: [{ name: "demo_skill", skillName: "demo-skill", description: "Demo" }],
+    });
+    expect(invocation).toBeNull();
+  });
+});

src/auto-reply/skill-commands.ts

@@ -0,0 +1,46 @@
+import type { ClawdbotConfig } from "../config/config.js";
+import { getRemoteSkillEligibility } from "../infra/skills-remote.js";
+import { buildWorkspaceSkillCommandSpecs, type SkillCommandSpec } from "../agents/skills.js";
+import { listChatCommands } from "./commands-registry.js";
+
+function resolveReservedCommandNames(): Set<string> {
+  const reserved = new Set<string>();
+  for (const command of listChatCommands()) {
+    if (command.nativeName) reserved.add(command.nativeName.toLowerCase());
+    for (const alias of command.textAliases) {
+      const trimmed = alias.trim();
+      if (!trimmed.startsWith("/")) continue;
+      reserved.add(trimmed.slice(1).toLowerCase());
+    }
+  }
+  return reserved;
+}
+
+export function listSkillCommandsForWorkspace(params: {
+  workspaceDir: string;
+  cfg: ClawdbotConfig;
+  skillFilter?: string[];
+}): SkillCommandSpec[] {
+  return buildWorkspaceSkillCommandSpecs(params.workspaceDir, {
+    config: params.cfg,
+    skillFilter: params.skillFilter,
+    eligibility: { remote: getRemoteSkillEligibility() },
+    reservedNames: resolveReservedCommandNames(),
+  });
+}
+
+export function resolveSkillCommandInvocation(params: {
+  commandBodyNormalized: string;
+  skillCommands: SkillCommandSpec[];
+}): { command: SkillCommandSpec; args?: string } | null {
+  const trimmed = params.commandBodyNormalized.trim();
+  if (!trimmed.startsWith("/")) return null;
+  const match = trimmed.match(/^\/([^\s]+)(?:\s+([\s\S]+))?$/);
+  if (!match) return null;
+  const commandName = match[1]?.trim().toLowerCase();
+  if (!commandName) return null;
+  const command = params.skillCommands.find((entry) => entry.name.toLowerCase() === commandName);
+  if (!command) return null;
+  const args = match[2]?.trim();
+  return { command, args: args || undefined };
+}

src/auto-reply/status.test.ts

@@ -318,6 +318,22 @@ describe("buildCommandsMessage", () => {
     expect(text).not.toContain("/config");
     expect(text).not.toContain("/debug");
   });
+
+  it("includes skill commands when provided", () => {
+    const text = buildCommandsMessage(
+      {
+        commands: { config: false, debug: false },
+      } as ClawdbotConfig,
+      [
+        {
+          name: "demo_skill",
+          skillName: "demo-skill",
+          description: "Demo skill",
+        },
+      ],
+    );
+    expect(text).toContain("/demo_skill - Demo skill");
+  });
 });
 
 describe("buildHelpMessage", () => {

src/auto-reply/status.ts

@@ -22,6 +22,7 @@ import {
 } from "../utils/usage-format.js";
 import { VERSION } from "../version.js";
 import { listChatCommands, listChatCommandsForConfig } from "./commands-registry.js";
+import type { SkillCommandSpec } from "../agents/skills.js";
 import type { ElevatedLevel, ReasoningLevel, ThinkLevel, VerboseLevel } from "./thinking.js";
 
 type AgentConfig = Partial<NonNullable<NonNullable<ClawdbotConfig["agents"]>["defaults"]>>;
@@ -352,9 +353,14 @@ export function buildHelpMessage(cfg?: ClawdbotConfig): string {
   ].join("\n");
 }
 
-export function buildCommandsMessage(cfg?: ClawdbotConfig): string {
+export function buildCommandsMessage(
+  cfg?: ClawdbotConfig,
+  skillCommands?: SkillCommandSpec[],
+): string {
   const lines = ["ℹ️ Slash commands"];
-  const commands = cfg ? listChatCommandsForConfig(cfg) : listChatCommands();
+  const commands = cfg
+    ? listChatCommandsForConfig(cfg, { skillCommands })
+    : listChatCommands({ skillCommands });
   for (const command of commands) {
     const primary = command.nativeName
       ? `/${command.nativeName}`

src/channels/plugins/onboarding/whatsapp.ts

@@ -27,16 +27,6 @@ function setWhatsAppAllowFrom(cfg: ClawdbotConfig, allowFrom?: string[]): Clawdb
   return mergeWhatsAppConfig(cfg, { allowFrom }, { unsetOnUndefined: ["allowFrom"] });
 }
 
-function setMessagesResponsePrefix(cfg: ClawdbotConfig, responsePrefix?: string): ClawdbotConfig {
-  return {
-    ...cfg,
-    messages: {
-      ...cfg.messages,
-      responsePrefix,
-    },
-  };
-}
-
 function setWhatsAppSelfChatMode(cfg: ClawdbotConfig, selfChatMode: boolean): ClawdbotConfig {
   return mergeWhatsAppConfig(cfg, { selfChatMode });
 }
@@ -65,7 +55,6 @@ async function promptWhatsAppAllowFrom(
   const existingPolicy = cfg.channels?.whatsapp?.dmPolicy ?? "pairing";
   const existingAllowFrom = cfg.channels?.whatsapp?.allowFrom ?? [];
   const existingLabel = existingAllowFrom.length > 0 ? existingAllowFrom.join(", ") : "unset";
-  const existingResponsePrefix = cfg.messages?.responsePrefix;
 
   if (options?.forceAllowlist) {
     await prompter.note(
@@ -96,17 +85,8 @@ async function promptWhatsAppAllowFrom(
     let next = setWhatsAppSelfChatMode(cfg, true);
     next = setWhatsAppDmPolicy(next, "allowlist");
     next = setWhatsAppAllowFrom(next, unique);
-    if (existingResponsePrefix === undefined) {
-      next = setMessagesResponsePrefix(next, "[clawdbot]");
-    }
     await prompter.note(
-      [
-        "Allowlist mode enabled.",
-        `- allowFrom includes ${normalized}`,
-        existingResponsePrefix === undefined
-          ? "- responsePrefix set to [clawdbot]"
-          : "- responsePrefix left unchanged",
-      ].join("\n"),
+      ["Allowlist mode enabled.", `- allowFrom includes ${normalized}`].join("\n"),
       "WhatsApp allowlist",
     );
     return next;
@@ -163,17 +143,11 @@ async function promptWhatsAppAllowFrom(
     let next = setWhatsAppSelfChatMode(cfg, true);
     next = setWhatsAppDmPolicy(next, "allowlist");
     next = setWhatsAppAllowFrom(next, unique);
-    if (existingResponsePrefix === undefined) {
-      next = setMessagesResponsePrefix(next, "[clawdbot]");
-    }
     await prompter.note(
       [
         "Personal phone mode enabled.",
         "- dmPolicy set to allowlist (pairing skipped)",
         `- allowFrom includes ${normalized}`,
-        existingResponsePrefix === undefined
-          ? "- responsePrefix set to [clawdbot]"
-          : "- responsePrefix left unchanged",
       ].join("\n"),
       "WhatsApp personal phone",
     );

src/cli/update-cli.ts

@@ -28,6 +28,7 @@ const STEP_LABELS: Record<string, string> = {
   "ui:build": "Building UI",
   "clawdbot doctor": "Running doctor checks",
   "git rev-parse HEAD (after)": "Verifying update",
+  "global update": "Updating via package manager",
 };
 
 function getStepLabel(step: UpdateStepInfo): string {
@@ -206,13 +207,11 @@ export async function updateCommand(opts: UpdateCommandOptions): Promise<void> {
     if (result.reason === "not-git-install") {
       defaultRuntime.log(
         theme.warn(
-          "Skipped: this Clawdbot install isn't a git checkout. Update via your package manager, then run `clawdbot doctor` and `clawdbot daemon restart`.",
+          "Skipped: this Clawdbot install isn't a git checkout, and the package manager couldn't be detected. Update via your package manager, then run `clawdbot doctor` and `clawdbot daemon restart`.",
         ),
       );
       defaultRuntime.log(
-        theme.muted(
-          "Examples: `npm i -g clawdbot@latest`, `pnpm add -g clawdbot@latest`, or `bun add -g clawdbot@latest`",
-        ),
+        theme.muted("Examples: `npm i -g clawdbot@latest` or `pnpm add -g clawdbot@latest`"),
       );
     }
     defaultRuntime.exit(0);
@@ -251,9 +250,17 @@ export async function updateCommand(opts: UpdateCommandOptions): Promise<void> {
     }
   } else if (!opts.json) {
     defaultRuntime.log("");
-    defaultRuntime.log(
-      theme.muted("Tip: Run `clawdbot daemon restart` to apply updates to a running gateway."),
-    );
+    if (result.mode === "npm" || result.mode === "pnpm") {
+      defaultRuntime.log(
+        theme.muted(
+          "Tip: Run `clawdbot doctor`, then `clawdbot daemon restart` to apply updates to a running gateway.",
+        ),
+      );
+    } else {
+      defaultRuntime.log(
+        theme.muted("Tip: Run `clawdbot daemon restart` to apply updates to a running gateway."),
+      );
+    }
   }
 }
 
@@ -276,7 +283,7 @@ Examples:
 
 Notes:
   - For git installs: fetches, rebases, installs deps, builds, and runs doctor
-  - For global installs: use npm/pnpm/bun to reinstall (see docs/install/updating.md)
+  - For global installs: auto-updates via detected package manager when possible (see docs/install/updating.md)
   - Skips update if the working directory has uncommitted changes
 
 ${theme.muted("Docs:")} ${formatDocsLink("/cli/update", "docs.clawd.bot/cli/update")}`,

src/commands/doctor-update.ts

@@ -70,10 +70,7 @@ export async function maybeOfferUpdateBeforeDoctor(params: {
     note(
       [
         "This install is not a git checkout.",
-        "Update via your package manager, then rerun doctor:",
-        "- npm i -g clawdbot@latest",
-        "- pnpm add -g clawdbot@latest",
-        "- bun add -g clawdbot@latest",
+        "Run `clawdbot update` to update via your package manager (npm/pnpm), then rerun doctor.",
       ].join("\n"),
       "Update",
     );

src/discord/monitor/provider.ts

@@ -3,6 +3,8 @@ import { GatewayIntents, GatewayPlugin } from "@buape/carbon/gateway";
 import { Routes } from "discord-api-types/v10";
 import { resolveTextChunkLimit } from "../../auto-reply/chunk.js";
 import { listNativeCommandSpecsForConfig } from "../../auto-reply/commands-registry.js";
+import { listSkillCommandsForWorkspace } from "../../auto-reply/skill-commands.js";
+import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agents/agent-scope.js";
 import type { HistoryEntry } from "../../auto-reply/reply/history.js";
 import {
   isNativeCommandsExplicitlyDisabled,
@@ -116,7 +118,13 @@ export async function monitorDiscordProvider(opts: MonitorDiscordOpts = {}) {
     throw new Error("Failed to resolve Discord application id");
   }
 
-  const commandSpecs = nativeEnabled ? listNativeCommandSpecsForConfig(cfg) : [];
+  const skillCommands = nativeEnabled
+    ? listSkillCommandsForWorkspace({
+        workspaceDir: resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg)),
+        cfg,
+      })
+    : [];
+  const commandSpecs = nativeEnabled ? listNativeCommandSpecsForConfig(cfg, { skillCommands }) : [];
   const commands = commandSpecs.map((spec) =>
     createDiscordNativeCommand({
       command: spec,

src/gateway/gateway-models.profiles.live.test.ts

@@ -98,10 +98,19 @@ function isGoogleModelNotFoundText(text: string): boolean {
   return false;
 }
 
+function isGoogleishProvider(provider: string): boolean {
+  return provider === "google" || provider.startsWith("google-");
+}
+
 function isRefreshTokenReused(error: string): boolean {
   return /refresh_token_reused/i.test(error);
 }
 
+function isChatGPTUsageLimitErrorMessage(raw: string): boolean {
+  const msg = raw.toLowerCase();
+  return msg.includes("hit your chatgpt usage limit") && msg.includes("try again in");
+}
+
 function isMissingProfileError(error: string): boolean {
   return /no credentials found for profile/i.test(error);
 }
@@ -471,7 +480,30 @@ async function runGatewayModelSuite(params: GatewayModelSuiteParams) {
           if (payload?.status !== "ok") {
             throw new Error(`agent status=${String(payload?.status)}`);
           }
-          const text = extractPayloadText(payload?.result);
+          let text = extractPayloadText(payload?.result);
+          if (!text) {
+            logProgress(`${progressLabel}: empty response, retrying`);
+            const retry = await client.request<AgentFinalPayload>(
+              "agent",
+              {
+                sessionKey,
+                idempotencyKey: `idem-${randomUUID()}-retry`,
+                message:
+                  "Explain in 2-3 sentences how the JavaScript event loop handles microtasks vs macrotasks. Must mention both words: microtask and macrotask.",
+                thinking: params.thinkingLevel,
+                deliver: false,
+              },
+              { expectFinal: true },
+            );
+            if (retry?.status !== "ok") {
+              throw new Error(`agent status=${String(retry?.status)}`);
+            }
+            text = extractPayloadText(retry?.result);
+          }
+          if (!text && isGoogleishProvider(model.provider)) {
+            logProgress(`${progressLabel}: skip (google empty response)`);
+            break;
+          }
           if (
             isEmptyStreamText(text) &&
             (model.provider === "minimax" || model.provider === "openai-codex")
@@ -479,7 +511,7 @@ async function runGatewayModelSuite(params: GatewayModelSuiteParams) {
             logProgress(`${progressLabel}: skip (${model.provider} empty response)`);
             break;
           }
-          if (model.provider === "google" && isGoogleModelNotFoundText(text)) {
+          if (isGoogleishProvider(model.provider) && isGoogleModelNotFoundText(text)) {
             // Catalog drift: model IDs can disappear or become unavailable on the API.
             // Treat as skip when scanning "all models" for Google.
             logProgress(`${progressLabel}: skip (google model not found)`);
@@ -491,7 +523,13 @@ async function runGatewayModelSuite(params: GatewayModelSuiteParams) {
             phase: "prompt",
             label: params.label,
           });
-          if (!isMeaningful(text)) throw new Error(`not meaningful: ${text}`);
+          if (!isMeaningful(text)) {
+            if (isGoogleishProvider(model.provider) && /gemini/i.test(model.id)) {
+              logProgress(`${progressLabel}: skip (google not meaningful)`);
+              break;
+            }
+            throw new Error(`not meaningful: ${text}`);
+          }
           if (!/\bmicro\s*-?\s*tasks?\b/i.test(text) || !/\bmacro\s*-?\s*tasks?\b/i.test(text)) {
             throw new Error(`missing required keywords: ${text}`);
           }
@@ -735,6 +773,10 @@ async function runGatewayModelSuite(params: GatewayModelSuiteParams) {
             logProgress(`${progressLabel}: skip (codex refresh token reused)`);
             break;
           }
+          if (model.provider === "openai-codex" && isChatGPTUsageLimitErrorMessage(message)) {
+            logProgress(`${progressLabel}: skip (chatgpt usage limit)`);
+            break;
+          }
           if (isMissingProfileError(message)) {
             skippedCount += 1;
             logProgress(`${progressLabel}: skip (missing auth profile)`);

src/infra/update-runner.test.ts

@@ -96,6 +96,8 @@ describe("runGatewayUpdate", () => {
     await fs.writeFile(path.join(tempDir, "pnpm-lock.yaml"), "", "utf-8");
     const { runner, calls } = createRunner({
       [`git -C ${tempDir} rev-parse --show-toplevel`]: { code: 1 },
+      "npm root -g": { code: 1 },
+      "pnpm root -g": { code: 1 },
     });
 
     const result = await runGatewayUpdate({
@@ -106,9 +108,111 @@ describe("runGatewayUpdate", () => {
 
     expect(result.status).toBe("skipped");
     expect(result.reason).toBe("not-git-install");
-    expect(calls.some((call) => call.startsWith("pnpm "))).toBe(false);
-    expect(calls.some((call) => call.startsWith("npm "))).toBe(false);
-    expect(calls.some((call) => call.startsWith("bun "))).toBe(false);
+    expect(calls.some((call) => call.startsWith("pnpm add -g"))).toBe(false);
+    expect(calls.some((call) => call.startsWith("npm i -g"))).toBe(false);
+  });
+
+  it("updates global npm installs when detected", async () => {
+    const nodeModules = path.join(tempDir, "node_modules");
+    const pkgRoot = path.join(nodeModules, "clawdbot");
+    await fs.mkdir(pkgRoot, { recursive: true });
+    await fs.writeFile(
+      path.join(pkgRoot, "package.json"),
+      JSON.stringify({ name: "clawdbot", version: "1.0.0" }),
+      "utf-8",
+    );
+
+    const calls: string[] = [];
+    const runCommand = async (argv: string[]) => {
+      const key = argv.join(" ");
+      calls.push(key);
+      if (key === `git -C ${pkgRoot} rev-parse --show-toplevel`) {
+        return { stdout: "", stderr: "not a git repository", code: 128 };
+      }
+      if (key === "npm root -g") {
+        return { stdout: nodeModules, stderr: "", code: 0 };
+      }
+      if (key === "npm i -g clawdbot@latest") {
+        await fs.writeFile(
+          path.join(pkgRoot, "package.json"),
+          JSON.stringify({ name: "clawdbot", version: "2.0.0" }),
+          "utf-8",
+        );
+        return { stdout: "ok", stderr: "", code: 0 };
+      }
+      if (key === "pnpm root -g") {
+        return { stdout: "", stderr: "", code: 1 };
+      }
+      return { stdout: "", stderr: "", code: 0 };
+    };
+
+    const result = await runGatewayUpdate({
+      cwd: pkgRoot,
+      runCommand: async (argv, _options) => runCommand(argv),
+      timeoutMs: 5000,
+    });
+
+    expect(result.status).toBe("ok");
+    expect(result.mode).toBe("npm");
+    expect(result.before?.version).toBe("1.0.0");
+    expect(result.after?.version).toBe("2.0.0");
+    expect(calls.some((call) => call === "npm i -g clawdbot@latest")).toBe(true);
+  });
+
+  it("updates global bun installs when detected", async () => {
+    const oldBunInstall = process.env.BUN_INSTALL;
+    const bunInstall = path.join(tempDir, "bun-install");
+    process.env.BUN_INSTALL = bunInstall;
+
+    try {
+      const bunGlobalRoot = path.join(bunInstall, "install", "global", "node_modules");
+      const pkgRoot = path.join(bunGlobalRoot, "clawdbot");
+      await fs.mkdir(pkgRoot, { recursive: true });
+      await fs.writeFile(
+        path.join(pkgRoot, "package.json"),
+        JSON.stringify({ name: "clawdbot", version: "1.0.0" }),
+        "utf-8",
+      );
+
+      const calls: string[] = [];
+      const runCommand = async (argv: string[]) => {
+        const key = argv.join(" ");
+        calls.push(key);
+        if (key === `git -C ${pkgRoot} rev-parse --show-toplevel`) {
+          return { stdout: "", stderr: "not a git repository", code: 128 };
+        }
+        if (key === "npm root -g") {
+          return { stdout: "", stderr: "", code: 1 };
+        }
+        if (key === "pnpm root -g") {
+          return { stdout: "", stderr: "", code: 1 };
+        }
+        if (key === "bun add -g clawdbot@latest") {
+          await fs.writeFile(
+            path.join(pkgRoot, "package.json"),
+            JSON.stringify({ name: "clawdbot", version: "2.0.0" }),
+            "utf-8",
+          );
+          return { stdout: "ok", stderr: "", code: 0 };
+        }
+        return { stdout: "", stderr: "", code: 0 };
+      };
+
+      const result = await runGatewayUpdate({
+        cwd: pkgRoot,
+        runCommand: async (argv, _options) => runCommand(argv),
+        timeoutMs: 5000,
+      });
+
+      expect(result.status).toBe("ok");
+      expect(result.mode).toBe("bun");
+      expect(result.before?.version).toBe("1.0.0");
+      expect(result.after?.version).toBe("2.0.0");
+      expect(calls.some((call) => call === "bun add -g clawdbot@latest")).toBe(true);
+    } finally {
+      if (oldBunInstall === undefined) delete process.env.BUN_INSTALL;
+      else process.env.BUN_INSTALL = oldBunInstall;
+    }
   });
 
   it("rejects git roots that are not a clawdbot checkout", async () => {

src/infra/update-runner.ts

@@ -1,3 +1,4 @@
+import os from "node:os";
 import fs from "node:fs/promises";
 import path from "node:path";
 
@@ -158,6 +159,52 @@ async function detectPackageManager(root: string) {
   return "npm";
 }
 
+async function tryRealpath(value: string): Promise<string> {
+  try {
+    return await fs.realpath(value);
+  } catch {
+    return path.resolve(value);
+  }
+}
+
+async function detectGlobalInstallManager(
+  runCommand: CommandRunner,
+  pkgRoot: string,
+  timeoutMs: number,
+): Promise<"npm" | "pnpm" | "bun" | null> {
+  const pkgReal = await tryRealpath(pkgRoot);
+
+  const candidates: Array<{
+    manager: "npm" | "pnpm";
+    argv: string[];
+  }> = [
+    { manager: "npm", argv: ["npm", "root", "-g"] },
+    { manager: "pnpm", argv: ["pnpm", "root", "-g"] },
+  ];
+
+  for (const { manager, argv } of candidates) {
+    const res = await runCommand(argv, { timeoutMs }).catch(() => null);
+    if (!res) continue;
+    if (res.code !== 0) continue;
+    const globalRoot = res.stdout.trim();
+    if (!globalRoot) continue;
+
+    const globalReal = await tryRealpath(globalRoot);
+    const expected = path.join(globalReal, "clawdbot");
+    if (path.resolve(expected) === path.resolve(pkgReal)) return manager;
+  }
+
+  // Bun doesn't have an officially stable "global root" command across versions,
+  // so we check the common global install path (best-effort).
+  const bunInstall = process.env.BUN_INSTALL?.trim() || path.join(os.homedir(), ".bun");
+  const bunGlobalRoot = path.join(bunInstall, "install", "global", "node_modules");
+  const bunGlobalReal = await tryRealpath(bunGlobalRoot);
+  const bunExpected = path.join(bunGlobalReal, "clawdbot");
+  if (path.resolve(bunExpected) === path.resolve(pkgReal)) return "bun";
+
+  return null;
+}
+
 type RunStepOptions = {
   runCommand: CommandRunner;
   name: string;
@@ -220,6 +267,12 @@ function managerInstallArgs(manager: "pnpm" | "bun" | "npm") {
   return ["npm", "install"];
 }
 
+function globalUpdateArgs(manager: "pnpm" | "npm" | "bun") {
+  if (manager === "pnpm") return ["pnpm", "add", "-g", "clawdbot@latest"];
+  if (manager === "bun") return ["bun", "add", "-g", "clawdbot@latest"];
+  return ["npm", "i", "-g", "clawdbot@latest"];
+}
+
 // Total number of visible steps in a successful git update flow
 const GIT_UPDATE_TOTAL_STEPS = 9;
 
@@ -414,6 +467,32 @@ export async function runGatewayUpdate(opts: UpdateRunnerOptions = {}): Promise<
   }
 
   const beforeVersion = await readPackageVersion(pkgRoot);
+  const globalManager = await detectGlobalInstallManager(runCommand, pkgRoot, timeoutMs);
+  if (globalManager) {
+    const updateStep = await runStep({
+      runCommand,
+      name: "global update",
+      argv: globalUpdateArgs(globalManager),
+      cwd: pkgRoot,
+      timeoutMs,
+      progress,
+      stepIndex: 0,
+      totalSteps: 1,
+    });
+    const steps = [updateStep];
+    const afterVersion = await readPackageVersion(pkgRoot);
+    return {
+      status: updateStep.exitCode === 0 ? "ok" : "error",
+      mode: globalManager,
+      root: pkgRoot,
+      reason: updateStep.exitCode === 0 ? undefined : updateStep.name,
+      before: { version: beforeVersion },
+      after: { version: afterVersion },
+      steps,
+      durationMs: Date.now() - startedAt,
+    };
+  }
+
   return {
     status: "skipped",
     mode: "unknown",

src/slack/monitor/slash.ts

@@ -8,6 +8,8 @@ import {
   parseCommandArgs,
   resolveCommandArgMenu,
 } from "../../auto-reply/commands-registry.js";
+import { listSkillCommandsForWorkspace } from "../../auto-reply/skill-commands.js";
+import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../../agents/agent-scope.js";
 import { dispatchReplyWithDispatcher } from "../../auto-reply/reply/provider-dispatcher.js";
 import { resolveNativeCommandsEnabled } from "../../config/commands.js";
 import { danger, logVerbose } from "../../globals.js";
@@ -403,7 +405,15 @@ export function registerSlackMonitorSlashCommands(params: {
     providerSetting: account.config.commands?.native,
     globalSetting: cfg.commands?.native,
   });
-  const nativeCommands = nativeEnabled ? listNativeCommandSpecsForConfig(cfg) : [];
+  const skillCommands = nativeEnabled
+    ? listSkillCommandsForWorkspace({
+        workspaceDir: resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg)),
+        cfg,
+      })
+    : [];
+  const nativeCommands = nativeEnabled
+    ? listNativeCommandSpecsForConfig(cfg, { skillCommands })
+    : [];
   if (nativeCommands.length > 0) {
     for (const command of nativeCommands) {
       ctx.app.command(

src/telegram/bot-native-commands.ts

@@ -9,6 +9,8 @@ import {
   parseCommandArgs,
   resolveCommandArgMenu,
 } from "../auto-reply/commands-registry.js";
+import { listSkillCommandsForWorkspace } from "../auto-reply/skill-commands.js";
+import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
 import type { CommandArgs } from "../auto-reply/commands-registry.js";
 import { resolveTelegramCustomCommands } from "../config/telegram-custom-commands.js";
 import { dispatchReplyWithBufferedBlockDispatcher } from "../auto-reply/reply/provider-dispatcher.js";
@@ -43,10 +45,21 @@ export const registerTelegramNativeCommands = ({
   shouldSkipUpdate,
   opts,
 }) => {
-  const nativeCommands = nativeEnabled ? listNativeCommandSpecsForConfig(cfg) : [];
+  const skillCommands = nativeEnabled
+    ? listSkillCommandsForWorkspace({
+        workspaceDir: resolveAgentWorkspaceDir(cfg, resolveDefaultAgentId(cfg)),
+        cfg,
+      })
+    : [];
+  const nativeCommands = nativeEnabled
+    ? listNativeCommandSpecsForConfig(cfg, { skillCommands })
+    : [];
   const reservedCommands = new Set(
     listNativeCommandSpecs().map((command) => command.name.toLowerCase()),
   );
+  for (const command of skillCommands) {
+    reservedCommands.add(command.name.toLowerCase());
+  }
   const customResolution = resolveTelegramCustomCommands({
     commands: telegramCfg.customCommands,
     reservedCommands,

src/telegram/bot.test.ts

@@ -6,11 +6,20 @@ import {
   listNativeCommandSpecs,
   listNativeCommandSpecsForConfig,
 } from "../auto-reply/commands-registry.js";
+import { listSkillCommandsForWorkspace } from "../auto-reply/skill-commands.js";
+import { resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agents/agent-scope.js";
 import { resetInboundDedupe } from "../auto-reply/reply/inbound-dedupe.js";
 import * as replyModule from "../auto-reply/reply.js";
 import { createTelegramBot, getTelegramSequentialKey } from "./bot.js";
 import { resolveTelegramFetch } from "./fetch.js";
 
+function resolveSkillCommands(config: Parameters<typeof listNativeCommandSpecsForConfig>[0]) {
+  return listSkillCommandsForWorkspace({
+    workspaceDir: resolveAgentWorkspaceDir(config, resolveDefaultAgentId(config)),
+    cfg: config,
+  });
+}
+
 const { loadWebMedia } = vi.hoisted(() => ({
   loadWebMedia: vi.fn(),
 }));
@@ -187,7 +196,8 @@ describe("createTelegramBot", () => {
       command: string;
       description: string;
     }>;
-    const native = listNativeCommandSpecsForConfig(config).map((command) => ({
+    const skillCommands = resolveSkillCommands(config);
+    const native = listNativeCommandSpecsForConfig(config, { skillCommands }).map((command) => ({
       command: command.name,
       description: command.description,
     }));
@@ -227,7 +237,8 @@ describe("createTelegramBot", () => {
       command: string;
       description: string;
     }>;
-    const native = listNativeCommandSpecsForConfig(config).map((command) => ({
+    const skillCommands = resolveSkillCommands(config);
+    const native = listNativeCommandSpecsForConfig(config, { skillCommands }).map((command) => ({
       command: command.name,
       description: command.description,
     }));

src/web/auto-reply.web-auto-reply.prefixes-body-same-phone-marker-from.test.ts

@@ -258,6 +258,55 @@ describe("web auto-reply", () => {
     expect(reply).toHaveBeenCalledWith("🦞 hello there");
     resetLoadConfigMock();
   });
+  it("defaults responsePrefix for self-chat replies when unset", async () => {
+    setLoadConfigMock(() => ({
+      agents: {
+        list: [
+          {
+            id: "main",
+            default: true,
+            identity: { name: "Mainbot", emoji: "🦞", theme: "space lobster" },
+          },
+        ],
+      },
+      channels: { whatsapp: { allowFrom: ["+1555"] } },
+      messages: {
+        messagePrefix: undefined,
+        responsePrefix: undefined,
+      },
+    }));
+
+    let capturedOnMessage:
+      | ((msg: import("./inbound.js").WebInboundMessage) => Promise<void>)
+      | undefined;
+    const reply = vi.fn();
+    const listenerFactory = async (opts: {
+      onMessage: (msg: import("./inbound.js").WebInboundMessage) => Promise<void>;
+    }) => {
+      capturedOnMessage = opts.onMessage;
+      return { close: vi.fn() };
+    };
+
+    const resolver = vi.fn().mockResolvedValue({ text: "hello there" });
+
+    await monitorWebChannel(false, listenerFactory, false, resolver);
+    expect(capturedOnMessage).toBeDefined();
+
+    await capturedOnMessage?.({
+      body: "hi",
+      from: "+1555",
+      to: "+1555",
+      selfE164: "+1555",
+      chatType: "direct",
+      id: "msg1",
+      sendComposing: vi.fn(),
+      reply,
+      sendMedia: vi.fn(),
+    });
+
+    expect(reply).toHaveBeenCalledWith("[Mainbot] hello there");
+    resetLoadConfigMock();
+  });
   it("does not deliver HEARTBEAT_OK responses", async () => {
     setLoadConfigMock(() => ({
       channels: { whatsapp: { allowFrom: ["*"] } },

src/web/auto-reply/monitor/process-message.ts

@@ -1,4 +1,8 @@
-import { resolveEffectiveMessagesConfig, resolveIdentityName } from "../../../agents/identity.js";
+import {
+  resolveEffectiveMessagesConfig,
+  resolveIdentityName,
+  resolveIdentityNamePrefix,
+} from "../../../agents/identity.js";
 import {
   extractShortModelName,
   type ResponsePrefixContext,
@@ -172,10 +176,17 @@ export async function processMessage(params: {
   const textLimit = params.maxMediaTextChunkLimit ?? resolveTextChunkLimit(params.cfg, "whatsapp");
   let didLogHeartbeatStrip = false;
   let didSendReply = false;
-  const responsePrefix = resolveEffectiveMessagesConfig(
-    params.cfg,
-    params.route.agentId,
-  ).responsePrefix;
+  const configuredResponsePrefix = params.cfg.messages?.responsePrefix;
+  const resolvedMessages = resolveEffectiveMessagesConfig(params.cfg, params.route.agentId);
+  const isSelfChat =
+    params.msg.chatType !== "group" &&
+    Boolean(params.msg.selfE164) &&
+    normalizeE164(params.msg.from) === normalizeE164(params.msg.selfE164 ?? "");
+  const responsePrefix =
+    resolvedMessages.responsePrefix ??
+    (configuredResponsePrefix === undefined && isSelfChat
+      ? (resolveIdentityNamePrefix(params.cfg, params.route.agentId) ?? "[clawdbot]")
+      : undefined);
 
   // Create mutable context for response prefix template interpolation
   let prefixContext: ResponsePrefixContext = {