@gguf/pigbot 0.0.6 → 0.0.7

package/extensions/bluebubbles/src/onboarding.ts

@@ -1,17 +1,17 @@
 import type {
   ChannelOnboardingAdapter,
   ChannelOnboardingDmPolicy,
-  MoltbotConfig,
+  OpenClawConfig,
   DmPolicy,
   WizardPrompter,
-} from "clawdbot/plugin-sdk";
+} from "openclaw/plugin-sdk";
 import {
   DEFAULT_ACCOUNT_ID,
   addWildcardAllowFrom,
   formatDocsLink,
   normalizeAccountId,
   promptAccountId,
-} from "clawdbot/plugin-sdk";
+} from "openclaw/plugin-sdk";
 import {
   listBlueBubblesAccountIds,
   resolveBlueBubblesAccount,
@@ -22,7 +22,7 @@ import { parseBlueBubblesAllowTarget, normalizeBlueBubblesHandle } from "./targe
 
 const channel = "bluebubbles" as const;
 
-function setBlueBubblesDmPolicy(cfg: MoltbotConfig, dmPolicy: DmPolicy): MoltbotConfig {
+function setBlueBubblesDmPolicy(cfg: OpenClawConfig, dmPolicy: DmPolicy): OpenClawConfig {
   const allowFrom =
     dmPolicy === "open" ? addWildcardAllowFrom(cfg.channels?.bluebubbles?.allowFrom) : undefined;
   return {
@@ -39,10 +39,10 @@ function setBlueBubblesDmPolicy(cfg: MoltbotConfig, dmPolicy: DmPolicy): Moltbot
 }
 
 function setBlueBubblesAllowFrom(
-  cfg: MoltbotConfig,
+  cfg: OpenClawConfig,
   accountId: string,
   allowFrom: string[],
-): MoltbotConfig {
+): OpenClawConfig {
   if (accountId === DEFAULT_ACCOUNT_ID) {
     return {
       ...cfg,
@@ -81,10 +81,10 @@ function parseBlueBubblesAllowFromInput(raw: string): string[] {
 }
 
 async function promptBlueBubblesAllowFrom(params: {
-  cfg: MoltbotConfig;
+  cfg: OpenClawConfig;
   prompter: WizardPrompter;
   accountId?: string;
-}): Promise<MoltbotConfig> {
+}): Promise<OpenClawConfig> {
   const accountId =
     params.accountId && normalizeAccountId(params.accountId)
       ? (normalizeAccountId(params.accountId) ?? DEFAULT_ACCOUNT_ID)
@@ -318,7 +318,7 @@ export const blueBubblesOnboardingAdapter: ChannelOnboardingAdapter = {
       [
         "Configure the webhook URL in BlueBubbles Server:",
         "1. Open BlueBubbles Server → Settings → Webhooks",
-        "2. Add your Moltbot gateway URL + webhook path",
+        "2. Add your OpenClaw gateway URL + webhook path",
         "   Example: https://your-gateway-host:3000/bluebubbles-webhook",
         "3. Enable the webhook and save",
         "",

package/extensions/bluebubbles/src/reactions.ts

@@ -1,5 +1,5 @@
 import { resolveBlueBubblesAccount } from "./accounts.js";
-import type { MoltbotConfig } from "clawdbot/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import { blueBubblesFetchWithTimeout, buildBlueBubblesApiUrl } from "./types.js";
 
 export type BlueBubblesReactionOpts = {
@@ -7,7 +7,7 @@ export type BlueBubblesReactionOpts = {
   password?: string;
   accountId?: string;
   timeoutMs?: number;
-  cfg?: MoltbotConfig;
+  cfg?: OpenClawConfig;
 };
 
 const REACTION_TYPES = new Set([

package/extensions/bluebubbles/src/runtime.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "clawdbot/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk";
 
 let runtime: PluginRuntime | null = null;
 

package/extensions/bluebubbles/src/send.ts

@@ -6,7 +6,7 @@ import {
   normalizeBlueBubblesHandle,
   parseBlueBubblesTarget,
 } from "./targets.js";
-import type { MoltbotConfig } from "clawdbot/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import {
   blueBubblesFetchWithTimeout,
   buildBlueBubblesApiUrl,
@@ -18,7 +18,7 @@ export type BlueBubblesSendOpts = {
   password?: string;
   accountId?: string;
   timeoutMs?: number;
-  cfg?: MoltbotConfig;
+  cfg?: OpenClawConfig;
   /** Message GUID to reply to (reply threading) */
   replyToMessageGuid?: string;
   /** Part index for reply (default: 0) */

package/extensions/copilot-proxy/README.md

@@ -1,4 +1,4 @@
-# Copilot Proxy (Clawdbot plugin)
+# Copilot Proxy (OpenClaw plugin)
 
 Provider plugin for the **Copilot Proxy** VS Code extension.
 
@@ -7,7 +7,7 @@ Provider plugin for the **Copilot Proxy** VS Code extension.
 Bundled plugins are disabled by default. Enable this one:
 
 ```bash
-clawdbot plugins enable copilot-proxy
+openclaw plugins enable copilot-proxy
 ```
 
 Restart the Gateway after enabling.
@@ -15,7 +15,7 @@ Restart the Gateway after enabling.
 ## Authenticate
 
 ```bash
-clawdbot models auth login --provider copilot-proxy --set-default
+openclaw models auth login --provider copilot-proxy --set-default
 ```
 
 ## Notes

package/extensions/copilot-proxy/index.ts

@@ -1,4 +1,4 @@
-import { emptyPluginConfigSchema } from "clawdbot/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 
 const DEFAULT_BASE_URL = "http://localhost:3000/v1";
 const DEFAULT_API_KEY = "n/a";

package/extensions/copilot-proxy/package.json

@@ -1,9 +1,9 @@
 {
-  "name": "@moltbot/copilot-proxy",
-  "version": "2026.1.26",
+  "name": "@openclaw/copilot-proxy",
+  "version": "2026.1.29",
   "type": "module",
-  "description": "Moltbot Copilot Proxy provider plugin",
-  "moltbot": {
+  "description": "OpenClaw Copilot Proxy provider plugin",
+  "openclaw": {
     "extensions": [
       "./index.ts"
     ]

package/extensions/diagnostics-otel/index.ts

@@ -1,5 +1,5 @@
-import type { MoltbotPluginApi } from "clawdbot/plugin-sdk";
-import { emptyPluginConfigSchema } from "clawdbot/plugin-sdk";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 
 import { createDiagnosticsOtelService } from "./src/service.js";
 
@@ -8,7 +8,7 @@ const plugin = {
   name: "Diagnostics OpenTelemetry",
   description: "Export diagnostics events to OpenTelemetry",
   configSchema: emptyPluginConfigSchema(),
-  register(api: MoltbotPluginApi) {
+  register(api: OpenClawPluginApi) {
     api.registerService(createDiagnosticsOtelService());
   },
 };

package/extensions/diagnostics-otel/package.json

@@ -1,9 +1,9 @@
 {
-  "name": "@moltbot/diagnostics-otel",
-  "version": "2026.1.26",
+  "name": "@openclaw/diagnostics-otel",
+  "version": "2026.1.29",
   "type": "module",
-  "description": "Moltbot diagnostics OpenTelemetry exporter",
-  "moltbot": {
+  "description": "OpenClaw diagnostics OpenTelemetry exporter",
+  "openclaw": {
     "extensions": [
       "./index.ts"
     ]

package/extensions/diagnostics-otel/src/service.test.ts

@@ -95,8 +95,8 @@ vi.mock("@opentelemetry/semantic-conventions", () => ({
   },
 }));
 
-vi.mock("clawdbot/plugin-sdk", async () => {
-  const actual = await vi.importActual<typeof import("clawdbot/plugin-sdk")>("clawdbot/plugin-sdk");
+vi.mock("openclaw/plugin-sdk", async () => {
+  const actual = await vi.importActual<typeof import("openclaw/plugin-sdk")>("openclaw/plugin-sdk");
   return {
     ...actual,
     registerLogTransport: registerLogTransportMock,
@@ -104,7 +104,7 @@ vi.mock("clawdbot/plugin-sdk", async () => {
 });
 
 import { createDiagnosticsOtelService } from "./service.js";
-import { emitDiagnosticEvent } from "clawdbot/plugin-sdk";
+import { emitDiagnosticEvent } from "openclaw/plugin-sdk";
 
 describe("diagnostics-otel service", () => {
   beforeEach(() => {
@@ -191,20 +191,20 @@ describe("diagnostics-otel service", () => {
       attempt: 2,
     });
 
-    expect(telemetryState.counters.get("moltbot.webhook.received")?.add).toHaveBeenCalled();
-    expect(telemetryState.histograms.get("moltbot.webhook.duration_ms")?.record).toHaveBeenCalled();
-    expect(telemetryState.counters.get("moltbot.message.queued")?.add).toHaveBeenCalled();
-    expect(telemetryState.counters.get("moltbot.message.processed")?.add).toHaveBeenCalled();
-    expect(telemetryState.histograms.get("moltbot.message.duration_ms")?.record).toHaveBeenCalled();
-    expect(telemetryState.histograms.get("moltbot.queue.wait_ms")?.record).toHaveBeenCalled();
-    expect(telemetryState.counters.get("moltbot.session.stuck")?.add).toHaveBeenCalled();
-    expect(telemetryState.histograms.get("moltbot.session.stuck_age_ms")?.record).toHaveBeenCalled();
-    expect(telemetryState.counters.get("moltbot.run.attempt")?.add).toHaveBeenCalled();
+    expect(telemetryState.counters.get("openclaw.webhook.received")?.add).toHaveBeenCalled();
+    expect(telemetryState.histograms.get("openclaw.webhook.duration_ms")?.record).toHaveBeenCalled();
+    expect(telemetryState.counters.get("openclaw.message.queued")?.add).toHaveBeenCalled();
+    expect(telemetryState.counters.get("openclaw.message.processed")?.add).toHaveBeenCalled();
+    expect(telemetryState.histograms.get("openclaw.message.duration_ms")?.record).toHaveBeenCalled();
+    expect(telemetryState.histograms.get("openclaw.queue.wait_ms")?.record).toHaveBeenCalled();
+    expect(telemetryState.counters.get("openclaw.session.stuck")?.add).toHaveBeenCalled();
+    expect(telemetryState.histograms.get("openclaw.session.stuck_age_ms")?.record).toHaveBeenCalled();
+    expect(telemetryState.counters.get("openclaw.run.attempt")?.add).toHaveBeenCalled();
 
     const spanNames = telemetryState.tracer.startSpan.mock.calls.map((call) => call[0]);
-    expect(spanNames).toContain("moltbot.webhook.processed");
-    expect(spanNames).toContain("moltbot.message.processed");
-    expect(spanNames).toContain("moltbot.session.stuck");
+    expect(spanNames).toContain("openclaw.webhook.processed");
+    expect(spanNames).toContain("openclaw.message.processed");
+    expect(spanNames).toContain("openclaw.session.stuck");
 
     expect(registerLogTransportMock).toHaveBeenCalledTimes(1);
     expect(registeredTransports).toHaveLength(1);

package/extensions/diagnostics-otel/src/service.ts

@@ -10,10 +10,10 @@ import { NodeSDK } from "@opentelemetry/sdk-node";
 import { ParentBasedSampler, TraceIdRatioBasedSampler } from "@opentelemetry/sdk-trace-base";
 import { SemanticResourceAttributes } from "@opentelemetry/semantic-conventions";
 
-import type { MoltbotPluginService, DiagnosticEventPayload } from "clawdbot/plugin-sdk";
-import { onDiagnosticEvent, registerLogTransport } from "clawdbot/plugin-sdk";
+import type { DiagnosticEventPayload, OpenClawPluginService } from "openclaw/plugin-sdk";
+import { onDiagnosticEvent, registerLogTransport } from "openclaw/plugin-sdk";
 
-const DEFAULT_SERVICE_NAME = "moltbot";
+const DEFAULT_SERVICE_NAME = "openclaw";
 
 function normalizeEndpoint(endpoint?: string): string | undefined {
   const trimmed = endpoint?.trim();
@@ -32,7 +32,7 @@ function resolveSampleRate(value: number | undefined): number | undefined {
   return value;
 }
 
-export function createDiagnosticsOtelService(): MoltbotPluginService {
+export function createDiagnosticsOtelService(): OpenClawPluginService {
   let sdk: NodeSDK | null = null;
   let logProvider: LoggerProvider | null = null;
   let stopLogTransport: (() => void) | null = null;
@@ -118,78 +118,78 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
         FATAL: 21 as SeverityNumber,
       };
 
-      const meter = metrics.getMeter("moltbot");
-      const tracer = trace.getTracer("moltbot");
+      const meter = metrics.getMeter("openclaw");
+      const tracer = trace.getTracer("openclaw");
 
-      const tokensCounter = meter.createCounter("moltbot.tokens", {
+      const tokensCounter = meter.createCounter("openclaw.tokens", {
         unit: "1",
         description: "Token usage by type",
       });
-      const costCounter = meter.createCounter("moltbot.cost.usd", {
+      const costCounter = meter.createCounter("openclaw.cost.usd", {
         unit: "1",
         description: "Estimated model cost (USD)",
       });
-      const durationHistogram = meter.createHistogram("moltbot.run.duration_ms", {
+      const durationHistogram = meter.createHistogram("openclaw.run.duration_ms", {
         unit: "ms",
         description: "Agent run duration",
       });
-      const contextHistogram = meter.createHistogram("moltbot.context.tokens", {
+      const contextHistogram = meter.createHistogram("openclaw.context.tokens", {
         unit: "1",
         description: "Context window size and usage",
       });
-      const webhookReceivedCounter = meter.createCounter("moltbot.webhook.received", {
+      const webhookReceivedCounter = meter.createCounter("openclaw.webhook.received", {
         unit: "1",
         description: "Webhook requests received",
       });
-      const webhookErrorCounter = meter.createCounter("moltbot.webhook.error", {
+      const webhookErrorCounter = meter.createCounter("openclaw.webhook.error", {
         unit: "1",
         description: "Webhook processing errors",
       });
-      const webhookDurationHistogram = meter.createHistogram("moltbot.webhook.duration_ms", {
+      const webhookDurationHistogram = meter.createHistogram("openclaw.webhook.duration_ms", {
         unit: "ms",
         description: "Webhook processing duration",
       });
-      const messageQueuedCounter = meter.createCounter("moltbot.message.queued", {
+      const messageQueuedCounter = meter.createCounter("openclaw.message.queued", {
         unit: "1",
         description: "Messages queued for processing",
       });
-      const messageProcessedCounter = meter.createCounter("moltbot.message.processed", {
+      const messageProcessedCounter = meter.createCounter("openclaw.message.processed", {
         unit: "1",
         description: "Messages processed by outcome",
       });
-      const messageDurationHistogram = meter.createHistogram("moltbot.message.duration_ms", {
+      const messageDurationHistogram = meter.createHistogram("openclaw.message.duration_ms", {
         unit: "ms",
         description: "Message processing duration",
       });
-      const queueDepthHistogram = meter.createHistogram("moltbot.queue.depth", {
+      const queueDepthHistogram = meter.createHistogram("openclaw.queue.depth", {
         unit: "1",
         description: "Queue depth on enqueue/dequeue",
       });
-      const queueWaitHistogram = meter.createHistogram("moltbot.queue.wait_ms", {
+      const queueWaitHistogram = meter.createHistogram("openclaw.queue.wait_ms", {
         unit: "ms",
         description: "Queue wait time before execution",
       });
-      const laneEnqueueCounter = meter.createCounter("moltbot.queue.lane.enqueue", {
+      const laneEnqueueCounter = meter.createCounter("openclaw.queue.lane.enqueue", {
         unit: "1",
         description: "Command queue lane enqueue events",
       });
-      const laneDequeueCounter = meter.createCounter("moltbot.queue.lane.dequeue", {
+      const laneDequeueCounter = meter.createCounter("openclaw.queue.lane.dequeue", {
         unit: "1",
         description: "Command queue lane dequeue events",
       });
-      const sessionStateCounter = meter.createCounter("moltbot.session.state", {
+      const sessionStateCounter = meter.createCounter("openclaw.session.state", {
         unit: "1",
         description: "Session state transitions",
       });
-      const sessionStuckCounter = meter.createCounter("moltbot.session.stuck", {
+      const sessionStuckCounter = meter.createCounter("openclaw.session.stuck", {
         unit: "1",
         description: "Sessions stuck in processing",
       });
-      const sessionStuckAgeHistogram = meter.createHistogram("moltbot.session.stuck_age_ms", {
+      const sessionStuckAgeHistogram = meter.createHistogram("openclaw.session.stuck_age_ms", {
         unit: "ms",
         description: "Age of stuck sessions",
       });
-      const runAttemptCounter = meter.createCounter("moltbot.run.attempt", {
+      const runAttemptCounter = meter.createCounter("openclaw.run.attempt", {
         unit: "1",
         description: "Run attempts",
       });
@@ -207,7 +207,7 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
               : {}),
           }),
         );
-        const otelLogger = logProvider.getLogger("moltbot");
+        const otelLogger = logProvider.getLogger("openclaw");
 
         stopLogTransport = registerLogTransport((logObj) => {
           const safeStringify = (value: unknown) => {
@@ -265,29 +265,29 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
           }
 
           const attributes: Record<string, string | number | boolean> = {
-            "moltbot.log.level": logLevelName,
+            "openclaw.log.level": logLevelName,
           };
-          if (meta?.name) attributes["moltbot.logger"] = meta.name;
+          if (meta?.name) attributes["openclaw.logger"] = meta.name;
           if (meta?.parentNames?.length) {
-            attributes["moltbot.logger.parents"] = meta.parentNames.join(".");
+            attributes["openclaw.logger.parents"] = meta.parentNames.join(".");
           }
           if (bindings) {
             for (const [key, value] of Object.entries(bindings)) {
               if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-                attributes[`moltbot.${key}`] = value;
+                attributes[`openclaw.${key}`] = value;
               } else if (value != null) {
-                attributes[`moltbot.${key}`] = safeStringify(value);
+                attributes[`openclaw.${key}`] = safeStringify(value);
               }
             }
           }
           if (numericArgs.length > 0) {
-            attributes["moltbot.log.args"] = safeStringify(numericArgs);
+            attributes["openclaw.log.args"] = safeStringify(numericArgs);
           }
           if (meta?.path?.filePath) attributes["code.filepath"] = meta.path.filePath;
           if (meta?.path?.fileLine) attributes["code.lineno"] = Number(meta.path.fileLine);
           if (meta?.path?.method) attributes["code.function"] = meta.path.method;
           if (meta?.path?.filePathWithLine) {
-            attributes["moltbot.code.location"] = meta.path.filePathWithLine;
+            attributes["openclaw.code.location"] = meta.path.filePathWithLine;
           }
 
           otelLogger.emit({
@@ -316,48 +316,48 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
 
       const recordModelUsage = (evt: Extract<DiagnosticEventPayload, { type: "model.usage" }>) => {
         const attrs = {
-          "moltbot.channel": evt.channel ?? "unknown",
-          "moltbot.provider": evt.provider ?? "unknown",
-          "moltbot.model": evt.model ?? "unknown",
+          "openclaw.channel": evt.channel ?? "unknown",
+          "openclaw.provider": evt.provider ?? "unknown",
+          "openclaw.model": evt.model ?? "unknown",
         };
 
         const usage = evt.usage;
-        if (usage.input) tokensCounter.add(usage.input, { ...attrs, "moltbot.token": "input" });
-        if (usage.output) tokensCounter.add(usage.output, { ...attrs, "moltbot.token": "output" });
+        if (usage.input) tokensCounter.add(usage.input, { ...attrs, "openclaw.token": "input" });
+        if (usage.output) tokensCounter.add(usage.output, { ...attrs, "openclaw.token": "output" });
         if (usage.cacheRead)
-          tokensCounter.add(usage.cacheRead, { ...attrs, "moltbot.token": "cache_read" });
+          tokensCounter.add(usage.cacheRead, { ...attrs, "openclaw.token": "cache_read" });
         if (usage.cacheWrite)
-          tokensCounter.add(usage.cacheWrite, { ...attrs, "moltbot.token": "cache_write" });
+          tokensCounter.add(usage.cacheWrite, { ...attrs, "openclaw.token": "cache_write" });
         if (usage.promptTokens)
-          tokensCounter.add(usage.promptTokens, { ...attrs, "moltbot.token": "prompt" });
-        if (usage.total) tokensCounter.add(usage.total, { ...attrs, "moltbot.token": "total" });
+          tokensCounter.add(usage.promptTokens, { ...attrs, "openclaw.token": "prompt" });
+        if (usage.total) tokensCounter.add(usage.total, { ...attrs, "openclaw.token": "total" });
 
         if (evt.costUsd) costCounter.add(evt.costUsd, attrs);
         if (evt.durationMs) durationHistogram.record(evt.durationMs, attrs);
         if (evt.context?.limit)
           contextHistogram.record(evt.context.limit, {
             ...attrs,
-            "moltbot.context": "limit",
+            "openclaw.context": "limit",
           });
         if (evt.context?.used)
           contextHistogram.record(evt.context.used, {
             ...attrs,
-            "moltbot.context": "used",
+            "openclaw.context": "used",
           });
 
         if (!tracesEnabled) return;
         const spanAttrs: Record<string, string | number> = {
           ...attrs,
-          "moltbot.sessionKey": evt.sessionKey ?? "",
-          "moltbot.sessionId": evt.sessionId ?? "",
-          "moltbot.tokens.input": usage.input ?? 0,
-          "moltbot.tokens.output": usage.output ?? 0,
-          "moltbot.tokens.cache_read": usage.cacheRead ?? 0,
-          "moltbot.tokens.cache_write": usage.cacheWrite ?? 0,
-          "moltbot.tokens.total": usage.total ?? 0,
+          "openclaw.sessionKey": evt.sessionKey ?? "",
+          "openclaw.sessionId": evt.sessionId ?? "",
+          "openclaw.tokens.input": usage.input ?? 0,
+          "openclaw.tokens.output": usage.output ?? 0,
+          "openclaw.tokens.cache_read": usage.cacheRead ?? 0,
+          "openclaw.tokens.cache_write": usage.cacheWrite ?? 0,
+          "openclaw.tokens.total": usage.total ?? 0,
         };
 
-        const span = spanWithDuration("moltbot.model.usage", spanAttrs, evt.durationMs);
+        const span = spanWithDuration("openclaw.model.usage", spanAttrs, evt.durationMs);
         span.end();
       };
 
@@ -365,8 +365,8 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
         evt: Extract<DiagnosticEventPayload, { type: "webhook.received" }>,
       ) => {
         const attrs = {
-          "moltbot.channel": evt.channel ?? "unknown",
-          "moltbot.webhook": evt.updateType ?? "unknown",
+          "openclaw.channel": evt.channel ?? "unknown",
+          "openclaw.webhook": evt.updateType ?? "unknown",
         };
         webhookReceivedCounter.add(1, attrs);
       };
@@ -375,16 +375,16 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
         evt: Extract<DiagnosticEventPayload, { type: "webhook.processed" }>,
       ) => {
         const attrs = {
-          "moltbot.channel": evt.channel ?? "unknown",
-          "moltbot.webhook": evt.updateType ?? "unknown",
+          "openclaw.channel": evt.channel ?? "unknown",
+          "openclaw.webhook": evt.updateType ?? "unknown",
         };
         if (typeof evt.durationMs === "number") {
           webhookDurationHistogram.record(evt.durationMs, attrs);
         }
         if (!tracesEnabled) return;
         const spanAttrs: Record<string, string | number> = { ...attrs };
-        if (evt.chatId !== undefined) spanAttrs["moltbot.chatId"] = String(evt.chatId);
-        const span = spanWithDuration("moltbot.webhook.processed", spanAttrs, evt.durationMs);
+        if (evt.chatId !== undefined) spanAttrs["openclaw.chatId"] = String(evt.chatId);
+        const span = spanWithDuration("openclaw.webhook.processed", spanAttrs, evt.durationMs);
         span.end();
       };
 
@@ -392,17 +392,17 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
         evt: Extract<DiagnosticEventPayload, { type: "webhook.error" }>,
       ) => {
         const attrs = {
-          "moltbot.channel": evt.channel ?? "unknown",
-          "moltbot.webhook": evt.updateType ?? "unknown",
+          "openclaw.channel": evt.channel ?? "unknown",
+          "openclaw.webhook": evt.updateType ?? "unknown",
         };
         webhookErrorCounter.add(1, attrs);
         if (!tracesEnabled) return;
         const spanAttrs: Record<string, string | number> = {
           ...attrs,
-          "moltbot.error": evt.error,
+          "openclaw.error": evt.error,
         };
-        if (evt.chatId !== undefined) spanAttrs["moltbot.chatId"] = String(evt.chatId);
-        const span = tracer.startSpan("moltbot.webhook.error", {
+        if (evt.chatId !== undefined) spanAttrs["openclaw.chatId"] = String(evt.chatId);
+        const span = tracer.startSpan("openclaw.webhook.error", {
           attributes: spanAttrs,
         });
         span.setStatus({ code: SpanStatusCode.ERROR, message: evt.error });
@@ -413,8 +413,8 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
         evt: Extract<DiagnosticEventPayload, { type: "message.queued" }>,
       ) => {
         const attrs = {
-          "moltbot.channel": evt.channel ?? "unknown",
-          "moltbot.source": evt.source ?? "unknown",
+          "openclaw.channel": evt.channel ?? "unknown",
+          "openclaw.source": evt.source ?? "unknown",
         };
         messageQueuedCounter.add(1, attrs);
         if (typeof evt.queueDepth === "number") {
@@ -426,8 +426,8 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
         evt: Extract<DiagnosticEventPayload, { type: "message.processed" }>,
       ) => {
         const attrs = {
-          "moltbot.channel": evt.channel ?? "unknown",
-          "moltbot.outcome": evt.outcome ?? "unknown",
+          "openclaw.channel": evt.channel ?? "unknown",
+          "openclaw.outcome": evt.outcome ?? "unknown",
         };
         messageProcessedCounter.add(1, attrs);
         if (typeof evt.durationMs === "number") {
@@ -435,12 +435,12 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
         }
         if (!tracesEnabled) return;
         const spanAttrs: Record<string, string | number> = { ...attrs };
-        if (evt.sessionKey) spanAttrs["moltbot.sessionKey"] = evt.sessionKey;
-        if (evt.sessionId) spanAttrs["moltbot.sessionId"] = evt.sessionId;
-        if (evt.chatId !== undefined) spanAttrs["moltbot.chatId"] = String(evt.chatId);
-        if (evt.messageId !== undefined) spanAttrs["moltbot.messageId"] = String(evt.messageId);
-        if (evt.reason) spanAttrs["moltbot.reason"] = evt.reason;
-        const span = spanWithDuration("moltbot.message.processed", spanAttrs, evt.durationMs);
+        if (evt.sessionKey) spanAttrs["openclaw.sessionKey"] = evt.sessionKey;
+        if (evt.sessionId) spanAttrs["openclaw.sessionId"] = evt.sessionId;
+        if (evt.chatId !== undefined) spanAttrs["openclaw.chatId"] = String(evt.chatId);
+        if (evt.messageId !== undefined) spanAttrs["openclaw.messageId"] = String(evt.messageId);
+        if (evt.reason) spanAttrs["openclaw.reason"] = evt.reason;
+        const span = spanWithDuration("openclaw.message.processed", spanAttrs, evt.durationMs);
         if (evt.outcome === "error") {
           span.setStatus({ code: SpanStatusCode.ERROR, message: evt.error });
         }
@@ -450,7 +450,7 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
       const recordLaneEnqueue = (
         evt: Extract<DiagnosticEventPayload, { type: "queue.lane.enqueue" }>,
       ) => {
-        const attrs = { "moltbot.lane": evt.lane };
+        const attrs = { "openclaw.lane": evt.lane };
         laneEnqueueCounter.add(1, attrs);
         queueDepthHistogram.record(evt.queueSize, attrs);
       };
@@ -458,7 +458,7 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
       const recordLaneDequeue = (
         evt: Extract<DiagnosticEventPayload, { type: "queue.lane.dequeue" }>,
       ) => {
-        const attrs = { "moltbot.lane": evt.lane };
+        const attrs = { "openclaw.lane": evt.lane };
         laneDequeueCounter.add(1, attrs);
         queueDepthHistogram.record(evt.queueSize, attrs);
         if (typeof evt.waitMs === "number") {
@@ -469,38 +469,38 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
       const recordSessionState = (
         evt: Extract<DiagnosticEventPayload, { type: "session.state" }>,
       ) => {
-        const attrs: Record<string, string> = { "moltbot.state": evt.state };
-        if (evt.reason) attrs["moltbot.reason"] = evt.reason;
+        const attrs: Record<string, string> = { "openclaw.state": evt.state };
+        if (evt.reason) attrs["openclaw.reason"] = evt.reason;
         sessionStateCounter.add(1, attrs);
       };
 
       const recordSessionStuck = (
         evt: Extract<DiagnosticEventPayload, { type: "session.stuck" }>,
       ) => {
-        const attrs: Record<string, string> = { "moltbot.state": evt.state };
+        const attrs: Record<string, string> = { "openclaw.state": evt.state };
         sessionStuckCounter.add(1, attrs);
         if (typeof evt.ageMs === "number") {
           sessionStuckAgeHistogram.record(evt.ageMs, attrs);
         }
         if (!tracesEnabled) return;
         const spanAttrs: Record<string, string | number> = { ...attrs };
-        if (evt.sessionKey) spanAttrs["moltbot.sessionKey"] = evt.sessionKey;
-        if (evt.sessionId) spanAttrs["moltbot.sessionId"] = evt.sessionId;
-        spanAttrs["moltbot.queueDepth"] = evt.queueDepth ?? 0;
-        spanAttrs["moltbot.ageMs"] = evt.ageMs;
-        const span = tracer.startSpan("moltbot.session.stuck", { attributes: spanAttrs });
+        if (evt.sessionKey) spanAttrs["openclaw.sessionKey"] = evt.sessionKey;
+        if (evt.sessionId) spanAttrs["openclaw.sessionId"] = evt.sessionId;
+        spanAttrs["openclaw.queueDepth"] = evt.queueDepth ?? 0;
+        spanAttrs["openclaw.ageMs"] = evt.ageMs;
+        const span = tracer.startSpan("openclaw.session.stuck", { attributes: spanAttrs });
         span.setStatus({ code: SpanStatusCode.ERROR, message: "session stuck" });
         span.end();
       };
 
       const recordRunAttempt = (evt: Extract<DiagnosticEventPayload, { type: "run.attempt" }>) => {
-        runAttemptCounter.add(1, { "moltbot.attempt": evt.attempt });
+        runAttemptCounter.add(1, { "openclaw.attempt": evt.attempt });
       };
 
       const recordHeartbeat = (
         evt: Extract<DiagnosticEventPayload, { type: "diagnostic.heartbeat" }>,
       ) => {
-        queueDepthHistogram.record(evt.queued, { "moltbot.channel": "heartbeat" });
+        queueDepthHistogram.record(evt.queued, { "openclaw.channel": "heartbeat" });
       };
 
       unsubscribe = onDiagnosticEvent((evt: DiagnosticEventPayload) => {
@@ -562,5 +562,5 @@ export function createDiagnosticsOtelService(): MoltbotPluginService {
         sdk = null;
       }
     },
-  } satisfies MoltbotPluginService;
+  } satisfies OpenClawPluginService;
 }