@blackbelt-technology/pi-agent-dashboard 0.4.6 → 0.5.1

package/packages/extension/src/pi-env.d.ts

@@ -1,15 +1,8 @@
 // Ambient declarations for pi runtime packages.
-// The actual types are provided by whichever host (pi or OMP) loads this extension.
+// The actual types are provided by whichever host loads this extension.
 // tsconfig paths handles resolution when one of the packages is installed;
 // these declarations serve as fallback when neither is available (e.g. CI, dev without pi).
-declare module "@mariozechner/pi-coding-agent" {
-  export type ExtensionAPI = import("@oh-my-pi/pi-coding-agent").ExtensionAPI;
-}
-declare module "@mariozechner/pi-ai" {
-  export function StringEnum<T extends readonly string[]>(values: T, schema?: Record<string, unknown>): any;
-}
-
-declare module "@oh-my-pi/pi-coding-agent" {
+declare module "@earendil-works/pi-coding-agent" {
   export interface ModelRegistry {
     getAvailable(): Array<{ provider: string; id: string }>;
     refresh(): void;
@@ -35,3 +28,17 @@ declare module "@oh-my-pi/pi-coding-agent" {
     events: EventBus;
   }
 }
+
+// Legacy fork — re-exports the same ExtensionAPI shape so existing installs still type-check.
+declare module "@mariozechner/pi-coding-agent" {
+  export type ExtensionAPI = import("@earendil-works/pi-coding-agent").ExtensionAPI;
+  export type ModelRegistry = import("@earendil-works/pi-coding-agent").ModelRegistry;
+  export type EventBus = import("@earendil-works/pi-coding-agent").EventBus;
+}
+
+declare module "@earendil-works/pi-ai" {
+  export function StringEnum<T extends readonly string[]>(values: T, schema?: Record<string, unknown>): any;
+}
+declare module "@mariozechner/pi-ai" {
+  export function StringEnum<T extends readonly string[]>(values: T, schema?: Record<string, unknown>): any;
+}

package/packages/extension/src/prompt-expander.ts

@@ -6,8 +6,9 @@
  * by reading template/skill files directly and expanding them.
  */
 import { readFileSync, existsSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
 import { readdirSync, statSync } from "node:fs";
+import { buildSkillBlock } from "@blackbelt-technology/pi-dashboard-shared/skill-block-parser.js";
 
 /** Scan directories for .md prompt template files */
 function findPromptTemplates(cwd: string): Map<string, string> {
@@ -97,7 +98,26 @@ export function expandPromptTemplateFromDisk(text: string, cwd: string, pi?: any
 
   try {
     const content = readTemplate(filePath);
-    // Simple arg substitution: replace $1, $2, etc. or just append args
+
+    // Skill detection: either the local-scan key starts with `skill:` or the
+    // pi.getCommands() fallback resolved a command whose `source === "skill"`
+    // (we re-check below). Skill expansions wrap in pi's `<skill>` envelope so
+    // the dashboard ingress path is byte-identical to pi's own _expandSkillCommand,
+    // which lets the client and server recover the slash-command form.
+    // See change: render-skill-invocations-collapsibly.
+    const isSkill = isSkillResolution(templateName, filePath, pi);
+    if (isSkill) {
+      const bareName = templateName.replace(/^skill:/, "");
+      return buildSkillBlock({
+        name: bareName,
+        filePath,
+        baseDir: dirname(filePath),
+        body: content,
+        userArgs: argsString || undefined,
+      });
+    }
+
+    // Plain prompt templates: append args after a blank line, no wrapper.
     if (argsString) {
       return `${content}\n\n${argsString}`;
     }
@@ -106,3 +126,31 @@ export function expandPromptTemplateFromDisk(text: string, cwd: string, pi?: any
     return text;
   }
 }
+
+/**
+ * Detect whether the resolved `filePath` came from a skill source.
+ *
+ * The local-scan key tells us directly when it starts with `skill:`. For the
+ * pi.getCommands() fallback we re-query and check `source === "skill"` against
+ * the same templateName.
+ */
+function isSkillResolution(
+  templateName: string,
+  filePath: string,
+  pi: any | undefined,
+): boolean {
+  if (templateName.startsWith("skill:")) return true;
+  // The colon-alias path (e.g. /opsx:continue) maps to a hyphen filename and is
+  // a prompt template, not a skill. Skills always use the `skill:` prefix in
+  // both the local scan and pi.getCommands().
+  if (!pi?.getCommands) return false;
+  try {
+    const commands = pi.getCommands();
+    const match = commands.find(
+      (c: any) => c.name === templateName && c.source === "skill" && c.path === filePath,
+    );
+    return !!match;
+  } catch {
+    return false;
+  }
+}

package/packages/extension/src/provider-register.ts

@@ -11,10 +11,11 @@
  *   flow:resolve-model / flow:get-available-models
  */
 
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import type { ProviderInfo } from "@blackbelt-technology/pi-dashboard-shared/types.js";
 
 // -- Types ----------------------------------------------------------------
 
@@ -288,6 +289,122 @@ export function getSessionInfo(): { provider: string; modelId: string } {
   return { provider: currentSessionProvider, modelId: currentSessionModelId };
 }
 
+// -- Provider catalogue (for dashboard /api/provider-auth/status) -------
+//
+// Pure derivation: given a captured `ModelRegistry` and the pi-ai
+// helpers (`findEnvKeys`, `getEnvApiKey`), build a flat ProviderInfo[]
+// covering every OAuth provider plus every distinct provider id from
+// `getAll()`. The bridge pushes this to the server alongside
+// `models_list`. See change: replace-hardcoded-provider-lists.
+
+type PiAiHelpers = {
+  findEnvKeys?: (id: string) => string[] | undefined;
+  getEnvApiKey?: (id: string) => string | undefined;
+};
+
+export function _buildProviderCatalogue(
+  modelRegistry: any,
+  piAi: PiAiHelpers,
+  customIds: ReadonlySet<string> = new Set(),
+): ProviderInfo[] {
+  if (!modelRegistry) return [];
+  const oauthIds = new Set<string>(
+    (modelRegistry.authStorage?.getOAuthProviders?.() ?? []).map((p: any) => p.id),
+  );
+  // The catalogue is the complete picture of what pi knows about —
+  // built-in providers, OAuth providers, AND custom providers registered
+  // by the dashboard via pi.registerProvider() from ~/.pi/agent/providers.json.
+  // Custom providers carry `custom: true` so consumers can decide what
+  // to surface where (e.g. the auth UI suppresses their API-key rows
+  // because they're managed by the LLM Providers settings section).
+  // Filtering decisions belong to consumers, not to this function.
+  // See change: replace-hardcoded-provider-lists.
+  const allIds = new Set<string>(oauthIds);
+  for (const m of (modelRegistry.getAll?.() ?? []) as Array<{ provider?: string }>) {
+    if (m.provider) allIds.add(m.provider);
+  }
+  return [...allIds].map((id) => {
+    let displayName = id;
+    try {
+      displayName = modelRegistry.getProviderDisplayName?.(id) ?? id;
+    } catch { /* fallback to id */ }
+    let configured = false;
+    let source: ProviderInfo["source"];
+    try {
+      const status = modelRegistry.authStorage?.getAuthStatus?.(id);
+      if (status) {
+        configured = !!status.configured;
+        source = status.source;
+      }
+    } catch { /* ignore */ }
+    let expires: number | undefined;
+    try {
+      const cred = modelRegistry.authStorage?.get?.(id);
+      if (cred?.type === "oauth" && typeof cred.expires === "number") {
+        expires = cred.expires;
+      }
+    } catch { /* ignore */ }
+    let envVar: string | undefined;
+    let ambient: boolean | undefined;
+    try {
+      const keys = piAi.findEnvKeys?.(id);
+      if (keys && keys.length > 0) envVar = keys[0];
+      if (piAi.getEnvApiKey?.(id) === "<authenticated>") ambient = true;
+    } catch { /* ignore */ }
+    return {
+      id,
+      displayName,
+      hasOAuth: oauthIds.has(id),
+      configured,
+      source,
+      envVar,
+      ambient,
+      expires,
+      custom: customIds.has(id) || undefined,
+    };
+  });
+}
+
+// Lazy-cached pi-ai module (in scope inside pi's process).
+let _piAiModule: PiAiHelpers | null = null;
+let _piAiLoadAttempted = false;
+async function loadPiAi(): Promise<PiAiHelpers> {
+  if (_piAiModule) return _piAiModule;
+  if (_piAiLoadAttempted) return {};
+  _piAiLoadAttempted = true;
+  try {
+    const mod: any = await import("@earendil-works/pi-ai");
+    _piAiModule = { findEnvKeys: mod.findEnvKeys, getEnvApiKey: mod.getEnvApiKey };
+    return _piAiModule;
+  } catch {
+    return {};
+  }
+}
+
+// Eagerly kick off pi-ai load at module import time so env-var hints
+// are populated by the time the first session_register fires. Failure
+// is silent; `buildProviderCatalogue` falls back to {} which still
+// produces a valid catalogue minus envVar/ambient hints.
+void loadPiAi();
+
+/**
+ * Public wrapper: returns the current provider catalogue, or [] when
+ * the model registry has not been captured yet. Marks providers the
+ * bridge itself registered (from `~/.pi/agent/providers.json` via
+ * `pi.registerProvider()`) with `custom: true` so consumers can
+ * suppress their API-key auth rows (those are managed by the LLM
+ * Providers settings section). The catalogue itself is complete —
+ * including custom providers — so other consumers (e.g. diagnostics)
+ * see the full picture.
+ */
+export function buildProviderCatalogue(): ProviderInfo[] {
+  const mr = getModelRegistry();
+  if (!mr) return [];
+  const piAi = _piAiModule ?? {};
+  const customIds = new Set<string>(lastRegistered.keys());
+  return _buildProviderCatalogue(mr, piAi, customIds);
+}
+
 export function getModelDisplayName(modelId: string): string {
   if (piRef) {
     const data: any = {};
@@ -319,6 +436,20 @@ function getModelRegistry(): any {
 // -- Provider registration (with auto-discovery) --------------------------
 
 async function registerEntry(pi: ExtensionAPI, name: string, entry: ProviderEntry): Promise<number> {
+  // Record snapshot SYNCHRONOUSLY before awaiting discovery so the very
+  // first providers_list push (typically fired from `session_start`
+  // shortly after `activate()` kicked off async registerEntry calls) carries
+  // the correct `custom: true` flags. Otherwise a slow / unreachable
+  // /v1/models endpoint causes custom providers from
+  // `~/.pi/agent/providers.json` to leak into Settings → Provider
+  // Authentication → API Keys until the discovery probe resolves.
+  // See change: fix-custom-provider-flag-race.
+  lastRegistered.set(name, {
+    baseUrl: entry.baseUrl,
+    apiKey: entry.apiKey,
+    api: entry.api ?? "openai-completions",
+  });
+
   const discovered = await discoverModels(entry.baseUrl, entry.apiKey);
 
   // Metadata (contextWindow, maxTokens, reasoning, cost, input) is resolved
@@ -347,13 +478,6 @@ async function registerEntry(pi: ExtensionAPI, name: string, entry: ProviderEntr
     models,
   });
 
-  // Record snapshot so reloadProviders can detect subsequent changes.
-  lastRegistered.set(name, {
-    baseUrl: entry.baseUrl,
-    apiKey: entry.apiKey,
-    api: entry.api ?? "openai-completions",
-  });
-
   // Notify bridge directly (same package — no cross-package event needed)
   onProvidersChanged?.();
 

package/packages/extension/src/retry-tracker.ts

@@ -0,0 +1,123 @@
+/**
+ * RetryTracker — synthesizes `auto_retry_start` / `auto_retry_end` events from
+ * observed pi events.
+ *
+ * Background: pi's ExtensionAPI does NOT expose `auto_retry_*` events to
+ * extensions (verified against pi 0.70/0.73 — see
+ * https://github.com/badlogic/pi-mono/discussions/2073). They fire only via
+ * `AgentSession._emit → _eventListeners` which only the embedded SDK can
+ * subscribe to.
+ *
+ * Workaround: pi-coding-agent's `_handleRetryableError` fires `message_end`
+ * for the failed assistant message BEFORE entering its retry sleep. The
+ * bridge sees that `message_end` via `pi.on("message_end")`. By matching
+ * the same regex pi-coding-agent uses internally, we can detect that a
+ * retry is about to happen and emit our own `auto_retry_start` to the
+ * dashboard. When the next non-error `message_end` or `agent_end` arrives,
+ * we emit `auto_retry_end`.
+ *
+ * `delayMs` and `maxAttempts` are unknowable from observed events (pi's
+ * settings are not exposed); we send sentinel `-1` for both. The
+ * RetryBanner renders an indeterminate "retrying…" UI in that case.
+ *
+ * See change: fix-provider-retry-infinite-loop.
+ */
+
+/**
+ * Regex copied verbatim from pi-coding-agent `agent-session.js`
+ * `_isRetryableError`. If pi adds new retryable categories, this regex
+ * goes stale — but the failure mode is "tracker silently misses some
+ * retries", never "tracker breaks". Sync at major pi version bumps.
+ */
+export const RETRYABLE_PATTERN =
+  /overloaded|provider.?returned.?error|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server.?error|internal.?error|network.?error|connection.?error|connection.?refused|connection.?lost|other side closed|fetch failed|upstream.?connect|reset before headers|socket hang up|ended without|http2 request did not get a response|timed? out|timeout|terminated|retry delay/i;
+
+export interface SyntheticRetryEvent {
+  eventType: "auto_retry_start" | "auto_retry_end";
+  data: Record<string, unknown>;
+}
+
+/** Minimal shape we pluck from a `message_end` event. */
+export interface ObservedAssistantMessage {
+  role?: string;
+  stopReason?: string;
+  errorMessage?: string;
+}
+
+export class RetryTracker {
+  /** sessionId → 1-based attempt counter for the current retry chain. */
+  private attempt = new Map<string, number>();
+
+  /**
+   * Process a `message_end` event. Returns a synthetic event the bridge
+   * should ALSO forward (after the original message_end), or null.
+   */
+  observeMessageEnd(
+    sessionId: string,
+    message: ObservedAssistantMessage | undefined | null,
+  ): SyntheticRetryEvent | null {
+    if (!message || message.role !== "assistant") return null;
+
+    if (message.stopReason === "error") {
+      const err = typeof message.errorMessage === "string" ? message.errorMessage : "";
+      if (!err || !RETRYABLE_PATTERN.test(err)) return null;
+      const next = (this.attempt.get(sessionId) ?? 0) + 1;
+      this.attempt.set(sessionId, next);
+      return {
+        eventType: "auto_retry_start",
+        data: { attempt: next, maxAttempts: -1, delayMs: -1, errorMessage: err },
+      };
+    }
+
+    // Non-error assistant message — clears any in-flight retry chain.
+    if (this.attempt.has(sessionId)) {
+      const last = this.attempt.get(sessionId) ?? 0;
+      this.attempt.delete(sessionId);
+      return { eventType: "auto_retry_end", data: { success: true, attempt: last } };
+    }
+    return null;
+  }
+
+  /**
+   * Process an `agent_end` event. Returns a synthetic event the bridge
+   * should forward BEFORE the original agent_end, or null.
+   *
+   * Always clears any in-flight retry tracking (terminal turn boundary).
+   */
+  observeAgentEnd(
+    sessionId: string,
+    agentEndData: { messages?: unknown } | undefined | null,
+  ): SyntheticRetryEvent | null {
+    const wasRetrying = this.attempt.has(sessionId);
+    const last = this.attempt.get(sessionId) ?? -1;
+    this.attempt.delete(sessionId);
+    if (!wasRetrying) return null;
+
+    // Inspect terminal message for error context.
+    const messages = agentEndData?.messages;
+    const lastMsg =
+      Array.isArray(messages) && messages.length > 0
+        ? (messages[messages.length - 1] as ObservedAssistantMessage)
+        : undefined;
+    if (lastMsg?.stopReason === "error" && typeof lastMsg.errorMessage === "string") {
+      return {
+        eventType: "auto_retry_end",
+        data: { success: false, attempt: last, finalError: lastMsg.errorMessage },
+      };
+    }
+    return { eventType: "auto_retry_end", data: { success: true, attempt: last } };
+  }
+
+  /**
+   * Notify the tracker of a user abort. Clears in-flight tracking so a
+   * subsequent agent_end does not double-emit auto_retry_end.
+   */
+  noteAbort(sessionId: string): void {
+    this.attempt.delete(sessionId);
+  }
+
+  /** Test-only / bridge-coordination: is a retry currently in flight? */
+  isRetrying(sessionId: string): boolean {
+    return this.attempt.has(sessionId);
+  }
+}

package/packages/extension/src/server-launcher.ts

@@ -45,6 +45,23 @@ export function resolveServerCliPath(): string {
   }
 }
 
+/**
+ * Build the environment object passed to the spawned server process.
+ * Always stamps DASHBOARD_STARTER=Bridge so the server knows it was
+ * launched by the pi bridge extension.
+ */
+export function buildSpawnEnv(
+  baseEnv: NodeJS.ProcessEnv = process.env,
+): Record<string, string> {
+  // Spread process.env (may contain undefined values); filter them out.
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(baseEnv)) {
+    if (v !== undefined) out[k] = v;
+  }
+  out["DASHBOARD_STARTER"] = "Bridge";
+  return out;
+}
+
 /**
  * Build the spawn arguments from config.
  */
@@ -94,7 +111,7 @@ export async function launchServer(config: DashboardConfig): Promise<LaunchResul
     const r = await spawnDetached({
       cmd: process.execPath,
       args: ["--import", loader, entry, ...args], // ban:raw-node-import-ok: entry gated by shouldUrlWrapEntry
-      env: { ...process.env },
+      env: { ...process.env, DASHBOARD_STARTER: "Bridge" },
       logFd,
     });
 

package/packages/extension/src/session-sync.ts

@@ -8,6 +8,7 @@ import { detectSessionSource } from "./source-detector.js";
 import { replayEntriesAsEvents } from "@blackbelt-technology/pi-dashboard-shared/state-replay.js";
 import { gatherGitInfo, gatherJjInfo } from "./vcs-info.js";
 import type { FlowInfo } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import { buildProviderCatalogue } from "./provider-register.js";
 
 /**
  * Send full state sync to the server (session_register, commands, flows, models).
@@ -38,7 +39,15 @@ export function sendStateSync(
   // dashboard restart) is a "reattach". Server applies the configured
   // `reattachPlacement` policy on "reattach".
   // See change: reattach-move-to-front.
-  const registerReason: "spawn" | "reattach" = bc.hasRegisteredOnce ? "reattach" : "spawn";
+  const isFirstRegister = !bc.hasRegisteredOnce;
+  const registerReason: "spawn" | "reattach" = isFirstRegister ? "spawn" : "reattach";
+
+  // Include the spawn correlation token (server-minted UUID injected via
+  // env var at spawn time) ONLY on the first register. Subsequent
+  // registers (reattach after dashboard restart, in-process Ctrl+F fork)
+  // omit it because the sessionId is already known to the server.
+  // See change: spawn-correlation-token (Decision 3).
+  const spawnToken = isFirstRegister ? process.env.PI_DASHBOARD_SPAWN_TOKEN : undefined;
 
   bc.connection.send({
     type: "session_register",
@@ -54,6 +63,7 @@ export function sendStateSync(
     eventCount,
     pid: process.pid,
     registerReason,
+    ...(spawnToken ? { spawnToken } : {}),
   });
 
   bc.hasRegisteredOnce = true;
@@ -72,6 +82,8 @@ export function sendStateSync(
         id: m.id,
       }));
       bc.connection.send({ type: "models_list", sessionId: bc.sessionId, models });
+      // See change: replace-hardcoded-provider-lists.
+      bc.connection.send({ type: "providers_list", sessionId: bc.sessionId, providers: buildProviderCatalogue() });
     } catch { /* ignore */ }
   }
 }
@@ -164,6 +176,8 @@ export function handleSessionChange(
         id: m.id,
       }));
       bc.connection.send({ type: "models_list", sessionId: bc.sessionId, models });
+      // See change: replace-hardcoded-provider-lists.
+      bc.connection.send({ type: "providers_list", sessionId: bc.sessionId, providers: buildProviderCatalogue() });
     } catch { /* ignore */ }
   }
 }

package/packages/extension/src/usage-limit-orderer.ts

@@ -0,0 +1,76 @@
+/**
+ * Usage-limit event orderer.
+ *
+ * Tracks per-session whether an `auto_retry_start` was forwarded without a
+ * matching `auto_retry_end`, and — when an `agent_end` arrives whose terminal
+ * assistant message has a usage-limit / quota errorMessage — synthesizes an
+ * `auto_retry_end { success: false }` to emit BEFORE the `agent_end`.
+ *
+ * Pure logic (no I/O). The bridge wires this into its forwarding pipeline.
+ *
+ * See change: fix-provider-retry-infinite-loop.
+ */
+
+export const USAGE_LIMIT_PATTERN =
+  /usage[_ ]limit[_ ]reached|usage_not_included|quota[_ ]exceeded|monthly limit|hourly limit|reset after \d+[hms]/i;
+
+export interface SyntheticEventEnvelope {
+  eventType: "auto_retry_end";
+  data: { success: false; attempt: -1; finalError: string };
+}
+
+export class UsageLimitOrderer {
+  /** sessionId → true while a retry is in flight (no auto_retry_end seen yet). */
+  private pending = new Set<string>();
+
+  /**
+   * Notify the orderer of an outbound `auto_retry_start` for sessionId.
+   */
+  noteRetryStart(sessionId: string): void {
+    this.pending.add(sessionId);
+  }
+
+  /**
+   * Notify the orderer of an outbound `auto_retry_end` for sessionId.
+   * Subsequent `agent_end` events will not synthesize unless a new retry
+   * has been started.
+   */
+  noteRetryEnd(sessionId: string): void {
+    this.pending.delete(sessionId);
+  }
+
+  /**
+   * Inspect an `agent_end` payload. If the terminal message has a
+   * usage-limit error AND we have an unmatched retry-start for this session,
+   * return the synthetic event the bridge should forward BEFORE the agent_end.
+   *
+   * Returns null when no synthesis is needed. Always clears the pending flag
+   * after a terminal agent_end (errored or not) so we don't double-synthesize.
+   */
+  maybeSynthesize(
+    sessionId: string,
+    agentEndData: Record<string, unknown> | undefined,
+  ): SyntheticEventEnvelope | null {
+    const wasPending = this.pending.has(sessionId);
+    // Always clear on agent_end: a terminal turn ends any retry tracking.
+    this.pending.delete(sessionId);
+
+    if (!wasPending || !agentEndData) return null;
+    const messages = agentEndData.messages;
+    if (!Array.isArray(messages) || messages.length === 0) return null;
+    const last = messages[messages.length - 1] as Record<string, unknown> | undefined;
+    if (!last || last.stopReason !== "error") return null;
+    const errorMessage = typeof last.errorMessage === "string" ? last.errorMessage : "";
+    if (!errorMessage || !USAGE_LIMIT_PATTERN.test(errorMessage)) return null;
+
+    return {
+      eventType: "auto_retry_end",
+      data: { success: false, attempt: -1, finalError: errorMessage },
+    };
+  }
+
+  /** Test-only: inspect pending state. */
+  hasPending(sessionId: string): boolean {
+    return this.pending.has(sessionId);
+  }
+}

package/packages/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-server",
-  "version": "0.4.6",
+  "version": "0.5.1",
   "description": "Dashboard server for monitoring and interacting with pi agent sessions",
   "type": "module",
   "repository": {
@@ -15,8 +15,8 @@
     "node": ">=22.18.0"
   },
   "piCompatibility": {
-    "minimum": "0.70.0",
-    "recommended": "0.70.0",
+    "minimum": "0.74.0",
+    "recommended": "0.74.0",
     "maximum": null
   },
   "main": "src/cli.ts",
@@ -31,9 +31,9 @@
     "postinstall": "node scripts/fix-pty-permissions.cjs"
   },
   "dependencies": {
-    "@blackbelt-technology/dashboard-plugin-runtime": "^0.4.6",
-    "@blackbelt-technology/pi-dashboard-extension": "^0.4.6",
-    "@blackbelt-technology/pi-dashboard-shared": "^0.4.6",
+    "@blackbelt-technology/dashboard-plugin-runtime": "^0.5.1",
+    "@blackbelt-technology/pi-dashboard-extension": "^0.5.1",
+    "@blackbelt-technology/pi-dashboard-shared": "^0.5.1",
     "@fastify/compress": "^8.3.1",
     "@fastify/cookie": "^11.0.2",
     "@fastify/cors": "^11.0.0",