@blackbelt-technology/pi-agent-dashboard 0.4.1 → 0.4.2

package/packages/server/src/server.ts

@@ -18,6 +18,8 @@ import { createPreferencesStore, type PreferencesStore } from "./preferences-sto
 import { createMetaPersistence, type MetaPersistence } from "./meta-persistence.js";
 import { createSessionOrderManager, type SessionOrderManager } from "./session-order-manager.js";
 import { createPendingForkRegistry, type PendingForkRegistry } from "./pending-fork-registry.js";
+import { createPendingAttachRegistry } from "./pending-attach-registry.js";
+import { createPendingResumeIntentRegistry } from "./pending-resume-intent-registry.js";
 
 // pending-load-manager removed — server loads sessions directly via DirectoryService
 import { createDirectoryService, type DirectoryService } from "./directory-service.js";
@@ -35,6 +37,7 @@ import { registerAuthPlugin, validateWsUpgrade } from "./auth-plugin.js";
 import { findBundledExtension, registerBridgeExtension } from "@blackbelt-technology/pi-dashboard-shared/bridge-register.js";
 import { createNetworkGuard, isLoopback, isBypassedHost } from "./localhost-guard.js";
 import type { AuthConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import { loadConfig, CONFIG_FILE } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import { registerSessionApi } from "./session-api.js";
 import { registerSessionRoutes } from "./routes/session-routes.js";
 import { registerGitRoutes } from "./routes/git-routes.js";
@@ -59,6 +62,11 @@ import { createEditorManager, type EditorManager } from "./editor-manager.js";
 import { createEditorPidRegistry } from "./editor-pid-registry.js";
 import { registerEditorRoutes } from "./routes/editor-routes.js";
 import { registerKnownServersRoutes } from "./routes/known-servers-routes.js";
+import { registerPluginConfigRoutes } from "./routes/plugin-config-routes.js";
+import { loadServerEntries, discoverPlugins, getPluginStatusStore } from "@blackbelt-technology/dashboard-plugin-runtime/server";
+import { createServerPluginContext } from "@blackbelt-technology/dashboard-plugin-runtime/server";
+import { getPluginConfig as getPluginConfigFromFile } from "@blackbelt-technology/pi-dashboard-shared/config.js";
+import { registerAllPluginBridges } from "@blackbelt-technology/pi-dashboard-shared/plugin-bridge-register.js";
 import { registerEditorProxy, handleEditorUpgrade } from "./editor-proxy.js";
 import { detectCodeServerBinary } from "./editor-detection.js";
 
@@ -107,6 +115,128 @@ export interface DashboardServer {
   piPort(): number | null;
 }
 
+// ── Post-install repair (centralized hook) ─────────────────────────
+// On every `installing → ready` bootstrap-state transition the server
+// re-runs the full ToolRegistry rescan, force-refreshes OpenSpec data
+// for every known directory, and refreshes pi-resources. Without this
+// the OpenSpec session-card buttons stay hidden until the next gated
+// poll tick (or never, if the gate's mtime heuristic declines).
+// See change: fix-openspec-buttons-after-bootstrap-install.
+
+import type { OpenSpecData } from "@blackbelt-technology/pi-dashboard-shared/types.js";
+import type { ServerToBrowserMessage } from "@blackbelt-technology/pi-dashboard-shared/browser-protocol.js";
+
+export interface PostInstallRepairDeps {
+  registry: { rescan(name?: string): void };
+  directoryService: {
+    knownDirectories(): string[];
+    getOpenSpecData(cwd: string): OpenSpecData | undefined;
+    refreshOpenSpec(cwd: string): Promise<OpenSpecData>;
+    refreshPiResources(cwd: string): Promise<unknown>;
+  };
+  browserGateway: { broadcastToAll(msg: ServerToBrowserMessage): void };
+}
+
+function isOpenSpecDataEmpty(d: OpenSpecData | undefined): boolean {
+  if (!d) return true;
+  return !d.initialized && (!d.changes || d.changes.length === 0);
+}
+
+/**
+ * Centralized post-install repair work fired on every `installing → ready`
+ * bootstrap-state transition. Idempotent. Failures per-cwd are isolated.
+ *
+ * Steps:
+ *   1) `registry.rescan()` (no arg — full registry invalidate). Restores
+ *      the literal contract from `unified-bootstrap-install` task 4.3.
+ *   2) For every `directoryService.knownDirectories()` cwd, force-refresh
+ *      OpenSpec (bypassing the mtime gate). If the prior cache was empty
+ *      or the refreshed payload differs, broadcast `openspec_update`.
+ *   3) For every cwd, force-refresh pi-resources (silent on failure).
+ *
+ * The DEBUG=pi-dashboard|openspec-poll envvar enables a single-line
+ * diagnostic log on completion, matching the existing daemon-log style.
+ */
+export async function runPostInstallRepair(deps: PostInstallRepairDeps): Promise<void> {
+  const debug =
+    typeof process !== "undefined" &&
+    typeof process.env?.DEBUG === "string" &&
+    /pi-dashboard|openspec-poll/.test(process.env.DEBUG);
+
+  // 1) full registry rescan
+  deps.registry.rescan();
+  if (debug) console.log("[bootstrap] post-install: rescanned tool registry");
+
+  const cwds = deps.directoryService.knownDirectories();
+
+  // 2) per-cwd OpenSpec force-refresh + selective broadcast
+  await Promise.all(
+    cwds.map(async (cwd) => {
+      try {
+        const prior = deps.directoryService.getOpenSpecData(cwd);
+        const fresh = await deps.directoryService.refreshOpenSpec(cwd);
+        const priorEmpty = isOpenSpecDataEmpty(prior);
+        const dataDiffers = JSON.stringify(prior) !== JSON.stringify(fresh);
+        if (priorEmpty || dataDiffers) {
+          deps.browserGateway.broadcastToAll({ type: "openspec_update", cwd, data: fresh });
+        }
+      } catch (err) {
+        console.error(
+          `[bootstrap] post-install openspec refresh failed for ${cwd}:`,
+          err,
+        );
+      }
+    }),
+  );
+
+  // 3) per-cwd pi-resources force-refresh (silent fail)
+  await Promise.all(
+    cwds.map(async (cwd) => {
+      try {
+        await deps.directoryService.refreshPiResources(cwd);
+      } catch {
+        // matches existing pattern in directory-service.ts::schedulePiResourcesTick
+      }
+    }),
+  );
+
+  if (debug) console.log("[bootstrap] post-install: openspec + pi-resources refresh complete");
+}
+
+export interface BootstrapTransitionHandlerDeps {
+  /** Invoked once per `installing → ready` transition, fire-and-forget. */
+  onTransitionToReady: () => Promise<void> | void;
+  /** Existing queue flush invoked on the same transition. */
+  flushQueue: () => Promise<void> | void;
+}
+
+/**
+ * Returns a stateful handler that drives `onTransitionToReady` and
+ * `flushQueue` once per `installing → ready` (or `failed → ready`)
+ * transition. The handler ignores the very first ready snapshot
+ * because the bootstrap state defaults to ready.
+ *
+ * Both callbacks run fire-and-forget so the subscribe callback returns
+ * synchronously — matches the existing `void bootstrapQueue.flushAll()`
+ * pattern in the inline subscribe call site.
+ */
+export function makeBootstrapTransitionHandler(
+  deps: BootstrapTransitionHandlerDeps,
+): (snapshot: { status: "ready" | "installing" | "failed" }) => void {
+  let last: "ready" | "installing" | "failed" = "ready";
+  return (snapshot) => {
+    if (last !== "ready" && snapshot.status === "ready") {
+      void Promise.resolve(deps.flushQueue()).catch((err) => {
+        console.error("[bootstrap] flushQueue failed:", err);
+      });
+      void Promise.resolve(deps.onTransitionToReady()).catch((err) => {
+        console.error("[bootstrap] post-install repair failed:", err);
+      });
+    }
+    last = snapshot.status;
+  };
+}
+
 export async function createServer(config: ServerConfig): Promise<DashboardServer> {
   // Ensure bridge extension is registered in pi's global settings
   // (needed for bundled installs where pi can't discover it from package.json)
@@ -176,11 +306,112 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       firstMessage: session.firstMessage,
       cachedAt: Date.now(),
     });
+    // When a session ends, drop its id from the persisted drag-reorder list
+    // for that cwd. Drag-reorder is meaningful for live sessions only; ended
+    // ones must fall to the bottom in their natural endedAt order (rendered
+    // top-of-bucket on most-recent-first) rather than retaining a position
+    // that interleaves them with active sessions.
+    // See change: pin-and-search-sessions, top-of-tier-on-status-change.
+    // Status-transition tracking: prune+broadcast runs ONCE per
+    // transition to ended. Subsequent `update()` calls on an already-
+    // ended session (e.g. heartbeat tail, click-induced state sync,
+    // late events from the bridge) do NOT re-trigger the prune —
+    // otherwise the card visibly jumps to the tail of the ended group
+    // every time the user interacts with it.
+    // See change: pin-and-search-sessions.
+    const wasEnded = endedSessionIds.has(sessionId);
+    const isEnded = session.status === "ended";
+    if (isEnded && !wasEnded) {
+      // Just transitioned alive→ended.
+      endedSessionIds.add(sessionId);
+      const orderBefore = sessionOrderManager.getOrder(session.cwd) ?? [];
+      sessionOrderManager.remove(session.cwd, sessionId);
+      const orderAfter = sessionOrderManager.getOrder(session.cwd) ?? [];
+      if (orderBefore.length !== orderAfter.length) {
+        browserGateway.broadcastToAll({
+          type: "sessions_reordered",
+          cwd: session.cwd,
+          sessionIds: orderAfter,
+        });
+      }
+    } else if (!isEnded && wasEnded) {
+      // Resume: ended→alive. Three real outcomes land here, distinguished
+      // by the value `pendingResumeIntents.consume(...)` returns:
+      //   "front"  — Resume button, REST resume, prompt-auto-resume.
+      //              User wants the card surfaced at the top of alive.
+      //   "keep"   — Drag-to-resume. The dropped slot was already
+      //              persisted via `reorder_sessions`; do NOT clobber it.
+      //   null     — Bridge auto-reattach (dashboard restarted, pi
+      //              process still alive, no user intent tagged).
+      //              Preserve the user's existing layout.
+      // We always clear the transition tracker so a future alive→ended
+      // for this session fires correctly.
+      // See changes: preserve-session-order-on-reboot,
+      //              top-of-tier-on-status-change,
+      //              differentiate-resume-intent-by-trigger.
+      endedSessionIds.delete(sessionId);
+      const intent = pendingResumeIntents.consume(sessionId);
+      if (intent === null) {
+        // Bridge auto-reattach — leave order alone.
+        return;
+      }
+      if (intent === "keep") {
+        // Drag-to-resume — dropped slot wins; the earlier reorder_sessions
+        // already broadcast. Do NOT mutate sessionOrder, do NOT broadcast.
+        return;
+      }
+      // intent === "front": move-to-front so the just-resumed card
+      // surfaces at the top of the alive tier, even on repeated end →
+      // resume cycles where the id might still be in the order.
+      sessionOrderManager.moveToFront(session.cwd, sessionId);
+      const next = sessionOrderManager.getOrder(session.cwd) ?? [];
+      browserGateway.broadcastToAll({
+        type: "sessions_reordered",
+        cwd: session.cwd,
+        sessionIds: next,
+      });
+    }
   };
+  // Track which session ids we've seen as ended at least once, so the
+  // onChange hook can detect actual alive→ended transitions vs. mere
+  // re-emits of the ended state.
+  const endedSessionIds = new Set<string>(
+    sessionManager.listAll().filter((s) => s.status === "ended").map((s) => s.id),
+  );
+
+  // Startup reconciliation: persisted `sessionOrder` may contain ended
+  // session ids from before the alive→ended prune was implemented. Strip
+  // them now so the next render sees a consistent state where ended ids
+  // never appear in the order pass.
+  // See change: pin-and-search-sessions.
+  for (const [cwd, ids] of Object.entries(sessionOrderManager.getAllOrders())) {
+    const aliveIds = ids.filter((id) => {
+      const s = sessionManager.get(id);
+      // Keep ids we don't know about — they may belong to other cwds or
+      // be live but not yet registered. Strip only the ones explicitly
+      // marked ended.
+      return !s || s.status !== "ended";
+    });
+    if (aliveIds.length !== ids.length) {
+      sessionOrderManager.reorder(cwd, aliveIds);
+    }
+  }
 
   // Track cwds with pending dashboard-spawned sessions (for writing .meta.json).
   // Uses a counter per cwd to handle multiple spawns and avoid reconnects consuming entries.
   const pendingDashboardSpawns = new Map<string, number>();
+
+  // Pending spawn-with-attach intents (cwd → FIFO queue of changeNames).
+  // Consumed in event-wiring.ts on session_register. See change:
+  // add-folder-task-checker-and-spawn-attach.
+  const pendingAttachRegistry = createPendingAttachRegistry();
+  // Pending user-initiated resume intents (sessionId → timestamp).
+  // Consumed by `sessionManager.onChange` in the ended→alive branch to
+  // gate the sessionOrder mutation behind explicit user intent so that
+  // bridge auto-reattach on dashboard reboot does not mutate the user's
+  // drag-order.
+  // See change: preserve-session-order-on-reboot.
+  const pendingResumeIntents = createPendingResumeIntentRegistry();
   // Track known session IDs so we can distinguish new sessions from reconnections.
   const knownSessionIds = new Set<string>();
   // Populate from persisted sessions
@@ -237,7 +468,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     },
   });
 
-  const browserGateway = createBrowserGateway(sessionManager, eventStore, piGateway, undefined, pendingForkRegistry, sessionOrderManager, preferencesStore, directoryService, terminalManager, pendingDashboardSpawns, config.maxWsBufferBytes);
+  const browserGateway = createBrowserGateway(sessionManager, eventStore, piGateway, undefined, pendingForkRegistry, sessionOrderManager, preferencesStore, directoryService, terminalManager, pendingDashboardSpawns, config.maxWsBufferBytes, pendingAttachRegistry, pendingResumeIntents);
 
   // Resolve package version once at startup
   const __require = createRequire(import.meta.url);
@@ -271,6 +502,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     directoryService,
     knownSessionIds,
     pendingDashboardSpawns,
+    pendingAttachRegistry,
   });
 
   // Auto-shutdown idle timer
@@ -362,17 +594,24 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   // See change: unified-bootstrap-install.
   const bootstrapState = createBootstrapState();
   const bootstrapQueue = createBootstrapQueue();
-  let lastBootstrapStatus: "ready" | "installing" | "failed" = "ready";
+  // Centralized post-install repair: full ToolRegistry rescan +
+  // OpenSpec / pi-resources force-refresh on every `installing → ready`
+  // transition. See change: fix-openspec-buttons-after-bootstrap-install.
+  const handleBootstrapTransition = makeBootstrapTransitionHandler({
+    flushQueue: () => bootstrapQueue.flushAll(),
+    onTransitionToReady: () =>
+      runPostInstallRepair({
+        registry: getDefaultRegistry(),
+        directoryService,
+        browserGateway,
+      }),
+  });
   const unsubscribeBootstrap = bootstrapState.subscribe((snapshot) => {
     browserGateway.broadcastToAll({
       type: "bootstrap_status_update",
       state: snapshot,
     });
-    // Flush queued pi-dependent operations on ready transition.
-    if (lastBootstrapStatus !== "ready" && snapshot.status === "ready") {
-      void bootstrapQueue.flushAll();
-    }
-    lastBootstrapStatus = snapshot.status;
+    handleBootstrapTransition(snapshot);
   });
   const unsubscribeQueueComplete = bootstrapQueue.onTicketComplete((evt) => {
     browserGateway.broadcastToAll({
@@ -392,6 +631,7 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
     pendingDashboardSpawns,
     bootstrapState,
     bootstrapQueue,
+    pendingResumeIntents,
   });
 
   // Register route modules
@@ -521,9 +761,16 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
   // Package management
   const packageManagerWrapper = new PackageManagerWrapper();
 
-  // Forward progress events to all browser clients
-  packageManagerWrapper.setProgressListener((operationId, event) => {
-    browserGateway.broadcastToAll({ type: "package_progress", operationId, event } as any);
+  // Forward progress events to all browser clients. The third arg
+  // (`moveId`) is set when the event is part of a composite move op;
+  // clients group events by moveId. See change: unify-package-management-ui.
+  packageManagerWrapper.setProgressListener((operationId, event, moveId) => {
+    browserGateway.broadcastToAll({
+      type: "package_progress",
+      operationId,
+      ...(moveId ? { moveId } : {}),
+      event,
+    } as any);
   });
 
   // On completion: broadcast to browsers + invalidate the recommended cache
@@ -538,6 +785,8 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       error: result.error,
       diagnostics: result.diagnostics,
       sessionsReloaded: (result as any).sessionsReloaded,
+      ...(result.moveId ? { moveId: result.moveId } : {}),
+      ...(result.partialSuccess ? { partialSuccess: result.partialSuccess } : {}),
     } as any);
     if (result.success) invalidateRecommendedCache();
   });
@@ -626,6 +875,10 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
 
   registerProviderAuthRoutes(fastify, { piGateway, browserGateway });
   registerKnownServersRoutes(fastify, { networkGuard, getPeerServers: () => peerServers });
+  registerPluginConfigRoutes(fastify, {
+    networkGuard,
+    broadcast: (msg) => browserGateway.broadcast(msg),
+  });
   registerProviderRoutes(fastify, { networkGuard, piGateway, browserGateway });
 
   // Serve static files / SPA fallback.
@@ -848,6 +1101,82 @@ export async function createServer(config: ServerConfig): Promise<DashboardServe
       // Discover sessions and start OpenSpec polling (async, non-blocking)
       discoverAndBroadcastSessions({ sessionManager, browserGateway, directoryService });
 
+      // Load plugin server entries (non-blocking; failures isolated per plugin)
+      loadServerEntries({
+        isEnabled: (pluginId) => {
+          const cfg = loadConfig();
+          const pluginCfg = getPluginConfigFromFile(cfg, pluginId) as Record<string, unknown>;
+          return pluginCfg.enabled !== false; // default: enabled
+        },
+        createContext: (plugin) => createServerPluginContext(
+          {
+            fastify,
+            sessionManager: {
+              listActive: () => sessionManager.listActive(),
+              listAll: () => sessionManager.listAll(),
+              getSession: (id: string) => sessionManager.get(id),
+            },
+            eventStore: {
+              getEvents: (sessionId) => eventStore.getEvents(sessionId, 0),
+              getLatestEvent: (sessionId) => {
+                const events = eventStore.getEvents(sessionId, 0);
+                return events.length > 0 ? events[events.length - 1] : undefined;
+              },
+            },
+            broadcastToSubscribers: (msg) => browserGateway.broadcast(msg as any),
+            // Plugin pi/browser handler registration — stub for now;
+            // full dynamic handler registration requires a registry refactor
+            // tracked in extract-*-as-plugin changes.
+            registerPiHandler: (_type, _handler) => {},
+            registerBrowserHandler: (_type, _handler) => {},
+            getPluginConfig: (id) => {
+              const cfg = loadConfig();
+              return getPluginConfigFromFile(cfg, id);
+            },
+            updatePluginConfig: async (id, partial) => {
+              // Inline partial write (reuses CONFIG_FILE path from shared config)
+              const cfg = loadConfig();
+              const current = getPluginConfigFromFile(cfg, id);
+              const merged = { ...current, ...partial };
+              let rawConfig: Record<string, unknown> = {};
+              try {
+                const raw = (await import('node:fs')).default.readFileSync(CONFIG_FILE, 'utf-8');
+                rawConfig = JSON.parse(raw);
+              } catch { /* start fresh */ }
+              rawConfig.plugins = { ...(rawConfig.plugins as Record<string, unknown> ?? {}), [id]: merged };
+              const fs = (await import('node:fs')).default;
+              const tmpFile = CONFIG_FILE + '.tmp.' + process.pid;
+              fs.writeFileSync(tmpFile, JSON.stringify(rawConfig, null, 2) + '\n');
+              fs.renameSync(tmpFile, CONFIG_FILE);
+              browserGateway.broadcast({ type: 'plugin_config_update', id, config: merged } as any);
+            },
+          },
+          plugin.manifest.id,
+        ),
+      }).catch((err) => console.error('[plugin-loader] Unexpected error:', err));
+
+      // Auto-register plugin bridge entries
+      const discoveredPlugins = discoverPlugins();
+      const pluginsWithBridges = discoveredPlugins
+        .filter(p => p.bridgeEntryPath)
+        .map(p => ({ pluginId: p.manifest.id, bridgePath: p.bridgeEntryPath! }));
+      if (pluginsWithBridges.length) {
+        const results = registerAllPluginBridges(pluginsWithBridges);
+        for (const [id, result] of Object.entries(results)) {
+          if (result.type === 'conflict') {
+            const store = getPluginStatusStore();
+            const existing = store.getStatus(id);
+            store.setStatus({
+              id,
+              enabled: existing?.enabled ?? true,
+              loaded: existing?.loaded ?? false,
+              error: `Bridge path conflict: existing=${result.existingPath}, new=${result.newPath}`,
+              claims: existing?.claims ?? 0,
+            });
+          }
+        }
+      }
+
       idleTimer.start();
     },
 

package/packages/server/src/session-api.ts

@@ -11,8 +11,10 @@ import type { ApiResponse } from "@blackbelt-technology/pi-dashboard-shared/type
 import { spawnPiSession } from "./process-manager.js";
 import { loadConfig } from "@blackbelt-technology/pi-dashboard-shared/config.js";
 import type { PendingForkRegistry } from "./pending-fork-registry.js";
+import type { PendingResumeIntentRegistry } from "./pending-resume-intent-registry.js";
 import type { BootstrapStateStore } from "./bootstrap-state.js";
 import type { BootstrapQueue } from "./bootstrap-queue.js";
+import { attachRenameTarget, detachShouldClearName } from "./proposal-attach-naming.js";
 
 export interface SessionApiDeps {
   sessionManager: SessionManager;
@@ -27,6 +29,13 @@ export interface SessionApiDeps {
    */
   bootstrapState?: BootstrapStateStore;
   bootstrapQueue?: BootstrapQueue;
+  /**
+   * User-resume-intent registry. Tagged in the resume endpoint so the
+   * `sessionManager.onChange` ended→alive branch can distinguish a
+   * REST-initiated user resume from a bridge auto-reattach on reboot.
+   * See change: preserve-session-order-on-reboot.
+   */
+  pendingResumeIntents?: PendingResumeIntentRegistry;
 }
 
 type IdParams = { Params: { id: string } };
@@ -39,7 +48,7 @@ function getSessionOrFail(sessionManager: SessionManager, id: string): { session
 }
 
 export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDeps) {
-  const { sessionManager, piGateway, browserGateway, pendingForkRegistry, pendingDashboardSpawns, bootstrapState, bootstrapQueue } = deps;
+  const { sessionManager, piGateway, browserGateway, pendingForkRegistry, pendingDashboardSpawns, bootstrapState, bootstrapQueue, pendingResumeIntents } = deps;
 
   /**
    * Gate pi-dependent operations on bootstrap status. Returns:
@@ -276,6 +285,12 @@ export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDep
       if (mode === "fork" && pendingForkRegistry) {
         pendingForkRegistry.recordFork(session.cwd, id);
       }
+      // Tag the user-resume intent BEFORE spawning. REST resume always
+      // uses "front" placement — the only "keep" path is drag-to-resume
+      // which goes through the WebSocket handler, not this REST endpoint.
+      // See changes: preserve-session-order-on-reboot,
+      //              differentiate-resume-intent-by-trigger.
+      pendingResumeIntents?.record(id, "front");
       const config = loadConfig();
       const spawnResult = await spawnPiSession(session.cwd, {
         sessionFile: session.sessionFile,
@@ -370,9 +385,11 @@ export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDep
       }
       const updates: Record<string, unknown> = { attachedProposal: changeName };
       const session = result.session;
-      if (!session.name?.trim()) {
-        updates.name = changeName;
-        piGateway.sendToSession(id, { type: "rename_session", sessionId: id, name: changeName });
+      // Idempotent auto-rename (see change: fix-mobile-attach-proposal-display).
+      const newName = attachRenameTarget(session, changeName);
+      if (newName !== undefined) {
+        updates.name = newName;
+        piGateway.sendToSession(id, { type: "rename_session", sessionId: id, name: newName });
       }
       sessionManager.update(id, updates);
       browserGateway.broadcastSessionUpdated(id, updates);
@@ -390,7 +407,15 @@ export function registerSessionApi(fastify: FastifyInstance, deps: SessionApiDep
         reply.code(404);
         return result.error;
       }
-      const updates = { attachedProposal: null, openspecPhase: null, openspecChange: null };
+      const session = result.session;
+      const updates: Record<string, unknown> = {
+        attachedProposal: null, openspecPhase: null, openspecChange: null,
+      };
+      // Idempotent auto-revert (see change: fix-mobile-attach-proposal-display).
+      if (detachShouldClearName(session)) {
+        updates.name = undefined;
+        piGateway.sendToSession(id, { type: "rename_session", sessionId: id, name: "" });
+      }
       sessionManager.update(id, updates);
       browserGateway.broadcastSessionUpdated(id, updates);
       return { success: true } satisfies ApiResponse;

package/packages/server/src/session-order-manager.ts

@@ -11,6 +11,16 @@ export interface SessionOrderManager {
   reorder(cwd: string, sessionIds: string[]): void;
   /** Remove a session from its cwd order. */
   remove(cwd: string, sessionId: string): void;
+  /**
+   * Move a session id to the front (index 0) of its cwd order. Idempotent:
+   * if the id is already at the front, the order is unchanged but a persist
+   * still fires (callers gate broadcasts on actual mutation).
+   * If the id is absent, it is inserted at the front.
+   * Used by the user-intent resume path to surface the just-resumed session
+   * at the top of the alive tier even on repeated end → resume cycles.
+   * See change: top-of-tier-on-status-change.
+   */
+  moveToFront(cwd: string, sessionId: string): void;
   /** Get order for a cwd, optionally filtering to only valid IDs. */
   getOrder(cwd: string, validIds?: Set<string>): string[];
   /** Get all cwd→order entries. */
@@ -59,6 +69,18 @@ export function createSessionOrderManager(preferencesStore: PreferencesStore): S
       persist();
     },
 
+    moveToFront(cwd: string, sessionId: string): void {
+      // remove + unshift = move-to-front. Works whether the id was
+      // absent, mid-list, or already at index 0.
+      // See change: top-of-tier-on-status-change.
+      if (!orderMap[cwd]) {
+        orderMap[cwd] = [];
+      }
+      orderMap[cwd] = orderMap[cwd].filter((id) => id !== sessionId);
+      orderMap[cwd].unshift(sessionId);
+      persist();
+    },
+
     getOrder(cwd: string, validIds?: Set<string>): string[] {
       const arr = orderMap[cwd];
       if (!arr) return [];

package/packages/server/src/session-scanner.ts

@@ -138,6 +138,15 @@ export function scanAllSessions(sessionsDir?: string): ScanResult {
         // Stale cache — re-extract stats and merge
         const stats = extractSessionStats(sessionFile);
         if (stats) {
+          // Pi's JSONL has no turn_end/contextUsage events, so stats.contextWindow
+          // is always inferContextWindow(model) — a hardcoded heuristic that pins
+          // any Claude model to 200k and ignores 1M Sonnet variants. The persisted
+          // meta.contextWindow came from a real live `turn_end` event, so it's
+          // authoritative; only fall back to the inferred value when the model
+          // changed (persisted value no longer applies) or none was persisted.
+          const effectiveModel = stats.model ?? meta.model;
+          const preserveContextWindow =
+            meta.contextWindow !== undefined && effectiveModel === meta.model;
           const updated: SessionMeta = {
             ...meta,
             model: stats.model ?? meta.model,
@@ -148,7 +157,7 @@ export function scanAllSessions(sessionsDir?: string): ScanResult {
             cacheWrite: stats.cacheWrite,
             cost: stats.cost,
             contextTokens: stats.lastTotalTokens,
-            contextWindow: stats.contextWindow,
+            contextWindow: preserveContextWindow ? meta.contextWindow : stats.contextWindow,
             cachedAt: Date.now(),
           };
           writeSessionMeta(sessionFile, updated);

package/packages/shared/package.json

@@ -1,14 +1,21 @@
 {
   "name": "@blackbelt-technology/pi-dashboard-shared",
-  "version": "0.4.1",
+  "version": "0.4.2",
   "description": "Shared types and utilities for pi-dashboard",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BlackBeltTechnology/pi-agent-dashboard",
+    "directory": "packages/shared"
+  },
   "publishConfig": {
     "access": "public"
   },
   "exports": {
     "./*.js": "./src/*.ts",
-    "./*": "./src/*"
+    "./*": "./src/*",
+    "./dashboard-plugin/*.js": "./src/dashboard-plugin/*.ts",
+    "./dashboard-plugin/*": "./src/dashboard-plugin/*"
   },
   "files": [
     "src/"