@fungi.computer/tourtois 0.3.1 → 0.4.0

package/dist/AppWorkbench.js

@@ -11,7 +11,7 @@ import { addressKey } from "@fungi.computer/nacre/app-directory";
 import { reconcileAppDirectory, reconcileAppWindowFromDirectory, } from "./app-directory-reconciliation.js";
 import { useAppDirectory } from "./app-directory.js";
 import { AppIcon } from "./app-icon.js";
-import { appForRole, composeOpenRequests, createAppLaunchDescriptor, attachWindowComputer, launchComputerId, launchForComputer, launchForRoleIntent, requireHandledNavigation, resolveFileEditorWindow, } from "./app-launch.js";
+import { appForRole, composeOpenRequests, createAppLaunchDescriptor, attachWindowComputer, launchComputerId, launchForComputer, findOpenFileCommand, launchForRoleIntent, requireHandledNavigation, resolveFileEditorWindow, } from "./app-launch.js";
 import { useAppSurfaceHost, } from "./app-surface.js";
 import { hasVisibleAppWindows, } from "./app-windows.js";
 import { desktopVisibility } from "./desktop-visibility.js";
@@ -37,7 +37,7 @@ function phoneShowDesktop(phone, covered, host, onFailure) {
         return undefined;
     return () => {
         void host
-            .execute("shell:desktop.show", { origin: "menu" })
+            .execute({ namespace: "shell", id: "desktop.show" }, { origin: "menu" })
             .then((outcome) => {
             if (outcome.status !== "handled") {
                 console.error("Phone Show desktop refused", outcome);
@@ -298,8 +298,10 @@ export function AppWorkbench({ paneLayerRef, phone, teamId, teamName, initialCom
             layout.zoom(null);
             focusWindow(launch.windowId);
             appSurfaceHost.focus?.(launch.surfaceId);
-            const commandId = `${launch.surfaceId}:open-file`;
-            const outcome = await appSurfaceHost.execute(commandId, {
+            const openFile = findOpenFileCommand(appSurfaceHost.snapshot(), launch.surfaceId);
+            if (!openFile)
+                throw new Error("The editor's open-file command is unavailable.");
+            const outcome = await appSurfaceHost.execute(openFile.command, {
                 origin: "programmatic",
                 arguments: input,
             });
@@ -456,7 +458,6 @@ export function AppWorkbench({ paneLayerRef, phone, teamId, teamName, initialCom
         };
         return launcher.icon ? { ...item, icon: launcher.icon } : item;
     }), ...extraLaunchers);
-    const inboxSurfaceId = useMemo(() => appForRole(directory, directoryRoles, "inbox")?.surfaceId ?? null, [directory, directoryRoles]);
     const visibility = desktopVisibility({
         hasVisibleWindows: hasVisibleAppWindows(appProjection) ||
             order.some((id) => !appProjection.windows.some((window) => window.windowId === id)),
@@ -530,7 +531,7 @@ export function AppWorkbench({ paneLayerRef, phone, teamId, teamName, initialCom
                         openAppPermissions(activeWindow.launch.surfaceId);
                     } }, activeWindow.windowId)) : null, systemMenuItems: systemMenuItems }), noticeContainer
                 ? createPortal(_jsx(Toaster, { id: "workbench-notices", position: "bottom-right", offset: 24, mobileOffset: 24, closeButton: true }), noticeContainer)
-                : null, _jsxs("div", { className: "relative min-h-0 flex-1", children: [_jsx(MaosaicoRegion, { layer: "desktop", style: { position: "absolute", inset: 0 }, "data-desktop-visibility": visibility, ref: desktopRef, "aria-hidden": covered ? true : undefined, children: _jsx(Desktop, { phone: phone, editing: desktopEditing, onEditingChange: setDesktopEditing, inboxSurfaceId: inboxSurfaceId, onOwner: receiveDesktopOwner, launcherItems: launchableItems, onAllApps: () => {
+                : null, _jsxs("div", { className: "relative min-h-0 flex-1", children: [_jsx(MaosaicoRegion, { layer: "desktop", style: { position: "absolute", inset: 0 }, "data-desktop-visibility": visibility, ref: desktopRef, "aria-hidden": covered ? true : undefined, children: _jsx(Desktop, { phone: phone, editing: desktopEditing, onEditingChange: setDesktopEditing, onOwner: receiveDesktopOwner, launcherItems: launchableItems, onAllApps: () => {
                                 setAppDialOpen(true);
                             }, paused: covered, apps: windowApps, needsUpdate: needsUpdate, onAppSettings: (app) => {
                                 setSettingsLocation({

package/dist/app-directory.js

@@ -12,8 +12,10 @@ export function useAppDirectory(teamId, directoryReader) {
         // result fresh for that handoff; explicit mutations still invalidate it.
         staleTime: 5_000,
         // Quiet open Apps need release availability too, not just after a request
-        // is refused. React Query pauses this polling while the page is hidden.
-        refetchInterval: 15_000,
+        // is refused. Every directory read costs the host a Registry read, and
+        // explicit mutations already invalidate this query, so the poll is a slow
+        // backstop. React Query pauses it while the page is hidden.
+        refetchInterval: 60_000,
     });
     return {
         query,

package/dist/app-launch.d.ts

@@ -1,5 +1,5 @@
 import type { AppOpenInput } from "@fungi.computer/agar/apps";
-import type { WhistleSnapshot } from "@fungi.computer/whistle";
+import { type WhistleMenuProjection, type WhistleSnapshot } from "@fungi.computer/whistle";
 import { type TourtoisAppSurfaceHost } from "./app-surface.js";
 import { createAppWindowManager, type AppLaunchDescriptor, type AppWindowManager, type AppWindowProjection } from "./app-windows.js";
 import type { WorkbenchDirectory } from "@fungi.computer/nacre/workbench-directory";
@@ -30,8 +30,15 @@ export declare function sameOfferedComputers(left: AppLaunchDescriptor, right: A
 export declare function launchComputerId(href: string): string | null;
 /** Keep the admitted App identity and point its existing surface at one Computer. */
 export declare function launchForComputer(launch: AppLaunchDescriptor, computerId: string): AppLaunchDescriptor;
+/** An editor surface's admitted open-file row, once the App registered it. */
+export declare function findOpenFileCommand(snapshot: WhistleSnapshot, surfaceId: string): WhistleMenuProjection | undefined;
 /** Find the user's already-open editor by its admitted open-file command. */
 export declare function findOpenFileEditor<Window extends Pick<AppWindowProjection, "launch">>(windows: readonly Window[], snapshot: WhistleSnapshot): Window | undefined;
+/**
+ * Resolve once a just-mounted App has registered a declared command: an App
+ * window is ready when its host connects, and registers its commands after.
+ */
+export declare function waitForSurfaceCommand(host: Pick<TourtoisAppSurfaceHost, "subscribe">, isRegistered: () => boolean): Promise<void>;
 /**
  * Select the Team's Files App for file navigation before it is mounted, or
  * any App that declares it opens files when no Files App handles them.
@@ -41,7 +48,7 @@ export declare function resolveFileEditorWindow(options: {
     apps: readonly AppDirectoryApp[];
     roles: AppDirectoryRoles;
     appWindows: ReturnType<typeof createAppWindowManager>;
-    appSurfaceHost: TourtoisAppSurfaceHost;
+    appSurfaceHost: Pick<TourtoisAppSurfaceHost, "snapshot" | "subscribe">;
     computerId: string;
     computers: readonly ComputerOption[];
     origin: string;

package/dist/app-launch.js

@@ -1,7 +1,9 @@
 import { defineIdFamily } from "@fungi.computer/cairn/id";
+import { sameWhistleCommand, } from "@fungi.computer/whistle";
 import {} from "./app-surface.js";
 import { AppError } from "@fungi.computer/agar";
 import { createAppWindowManager, } from "./app-windows.js";
+import { appSurfaceCommandKey } from "@fungi.computer/nacre/command-host";
 /** The Team's effective App for a role when it can be launched now. */
 export function appForRole(apps, roles, role) {
     const surfaceId = roles[role]?.surfaceId;
@@ -146,9 +148,37 @@ export function launchForComputer(launch, computerId) {
         href: href.pathname + href.search,
     };
 }
+/** An editor surface's admitted open-file row, once the App registered it. */
+export function findOpenFileCommand(snapshot, surfaceId) {
+    const key = appSurfaceCommandKey({ surfaceId, commandId: "open-file" });
+    return snapshot.menu.find((row) => sameWhistleCommand(row.command, key));
+}
 /** Find the user's already-open editor by its admitted open-file command. */
 export function findOpenFileEditor(windows, snapshot) {
-    return windows.find((window) => snapshot.menu.some((command) => command.commandId === `${window.launch.surfaceId}:open-file`));
+    return windows.find((window) => findOpenFileCommand(snapshot, window.launch.surfaceId) !== undefined);
+}
+/**
+ * Resolve once a just-mounted App has registered a declared command: an App
+ * window is ready when its host connects, and registers its commands after.
+ */
+export function waitForSurfaceCommand(host, isRegistered) {
+    if (isRegistered())
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const timeout = window.setTimeout(() => {
+            unsubscribe();
+            reject(new Error("The App did not register its declared command."));
+        }, 10_000);
+        const check = () => {
+            if (!isRegistered())
+                return;
+            window.clearTimeout(timeout);
+            unsubscribe();
+            resolve();
+        };
+        const unsubscribe = host.subscribe(check);
+        check();
+    });
 }
 /**
  * Select the Team's Files App for file navigation before it is mounted, or
@@ -184,7 +214,7 @@ export async function resolveFileEditorWindow(options) {
         .read()
         .windows.find((window) => window.windowId === candidate.windowId);
     const editor = mounted
-        ? findOpenFileEditor([mounted], options.appSurfaceHost.snapshot())
+        ? await waitForSurfaceCommand(options.appSurfaceHost, () => findOpenFileCommand(options.appSurfaceHost.snapshot(), mounted.launch.surfaceId) !== undefined).then(() => mounted, () => undefined)
         : undefined;
     if (editor)
         return { launch: editor.launch, opened: true };

package/dist/app-menus.js

@@ -56,7 +56,7 @@ export function AppMenus({ host, container: popover, }) {
                                     setPending(command.commandId);
                                     setMessage(null);
                                     void host
-                                        .execute(command.commandId, {
+                                        .execute(command.command, {
                                         origin: "menu",
                                         signal: controller.signal,
                                     })

package/dist/app-surface.d.ts

@@ -1,10 +1,11 @@
 import { type ReactNode } from "react";
-import type { WhistleCommand, WhistleExecutionInput, WhistleExecutionOutcome, WhistleMenuProjection, WhistleSnapshot } from "@fungi.computer/whistle";
+import type { WhistleCommand, WhistleCommandKey, WhistleExecutionInput, WhistleExecutionOutcome, WhistleMenuProjection, WhistleSnapshot } from "@fungi.computer/whistle";
 import type { AgentSessionSelection, AppNavigationState, AppStatusItem, FileNavigationInput } from "@fungi.computer/agar";
 import type { AppOpenInput, AppRoleChoice } from "@fungi.computer/agar/apps";
 import type { AppDeclaredCommand } from "@fungi.computer/puffball/app";
 import type { AppWindowMount } from "./app-windows.js";
 import type { WindowEvents } from "@fungi.computer/nacre/window-manager";
+import type { AppSurfaceCommandHost } from "@fungi.computer/nacre/command-host";
 /** What one mounted App may raise toward the shell. */
 export type TourtoisAppMountEvents = Pick<WindowEvents, "onDeliveryPending"> & Readonly<{
     onComputerChoice?: () => Promise<void>;
@@ -39,6 +40,8 @@ export type TourtoisAppSurfaceHost = Readonly<{
         appTitle: string;
         command: AppDeclaredCommand;
     }>[], run: (surfaceId: string, commandId: string) => Promise<void>) => () => void;
+    /** The App command a snapshot row runs, mounted or from the directory. */
+    appCommand: AppSurfaceCommandHost["appCommand"];
     /** Commands contributed by the currently focused App window. */
     menu: () => readonly WhistleMenuProjection[];
     /** The shell-owned semantic command graph, including every mounted App. */
@@ -49,7 +52,7 @@ export type TourtoisAppSurfaceHost = Readonly<{
      */
     active: () => WhistleSnapshot;
     /** Execute an active command or an exact host-owned programmatic action. */
-    execute: (commandId: string, input: WhistleExecutionInput) => Promise<WhistleExecutionOutcome>;
+    execute: (command: WhistleCommandKey, input: WhistleExecutionInput) => Promise<WhistleExecutionOutcome>;
     /** Bind one mounted App's explicit Agent Session selection to the shell. */
     reportAgentSessionSelection?: (teamId: string, mountId: string, selection: AgentSessionSelection | null) => Promise<void> | void;
     /** Observe focused App and command-graph changes. */

package/dist/command-dialogs.d.ts

@@ -22,7 +22,7 @@ export type PaletteApp = Readonly<{
 }>;
 /** Which-key list and `:` line for the focused window, drawn from Caps. */
 export declare function CommandDialogs({ host, state, focusedWindow, directoryApps, onStatus, finalFocus, container: dialog, renderIcon, }: Readonly<{
-    host: Pick<AppSurfaceCommandHost, "execute"> | null;
+    host: Pick<AppSurfaceCommandHost, "appCommand" | "execute"> | null;
     state: ShellCommandState;
     focusedWindow: Readonly<{
         launch: Readonly<{

package/dist/command-dialogs.js

@@ -8,12 +8,6 @@ import { leaderKeyMatches, leaderKeys, parseChord, } from "@fungi.computer/nacre
 function isMac() {
     return /Mac|iPhone|iPad/u.test(navigator.userAgent);
 }
-function appCommandId(surfaceId, commandId) {
-    return `${encodeURIComponent(surfaceId)}:${commandId}`;
-}
-function directoryCommandId(surfaceId, commandId) {
-    return `app-directory:${encodeURIComponent(surfaceId)}-${encodeURIComponent(commandId)}`;
-}
 function chordKey(key) {
     switch (key) {
         case "enter":
@@ -85,12 +79,26 @@ export function CommandDialogs({ host, state, focusedWindow, directoryApps, onSt
             surfaceId: focusedWindow.launch.surfaceId,
         }
         : undefined;
-    const focusedCommandIds = new Set(focusedApp?.commands.flatMap((command) => [
-        appCommandId(focusedApp.surfaceId, command.id),
-        directoryCommandId(focusedApp.surfaceId, command.id),
-    ]) ?? []);
+    // The App a palette row belongs to, and the command its Release declares.
+    const paletteEntry = (command) => {
+        const target = host?.appCommand(command);
+        if (target === undefined)
+            return undefined;
+        const app = target.surfaceId === focusedApp?.surfaceId
+            ? focusedApp
+            : command.sourceId === appDirectorySourceId
+                ? directoryApps.find((entry) => entry.surfaceId === target.surfaceId)
+                : undefined;
+        if (app === undefined)
+            return undefined;
+        return {
+            app,
+            declared: app.commands.find((entry) => entry.id === target.commandId),
+        };
+    };
     const isFocusedCommand = (command) => command.scope === focusedApp?.surfaceId ||
-        focusedCommandIds.has(command.commandId);
+        (focusedApp !== undefined &&
+            paletteEntry(command)?.app.surfaceId === focusedApp.surfaceId);
     const orderedPaletteRows = [
         ...palette.filter(isFocusedCommand),
         ...palette.filter((command) => command.sourceId === appDirectorySourceId && !isFocusedCommand(command)),
@@ -104,18 +112,11 @@ export function CommandDialogs({ host, state, focusedWindow, directoryApps, onSt
         seenPaletteIds.add(command.commandId);
         return true;
     });
-    const appByCommandId = new Map();
-    if (focusedApp)
-        for (const command of focusedApp.commands)
-            appByCommandId.set(appCommandId(focusedApp.surfaceId, command.id), focusedApp);
-    for (const app of directoryApps)
-        for (const command of app.commands)
-            appByCommandId.set(directoryCommandId(app.surfaceId, command.id), app);
     const mac = isMac();
-    const run = useCallback((commandId, origin) => {
+    const run = useCallback((command, origin) => {
         if (!host)
             return;
-        void host.execute(commandId, { origin }).then((outcome) => {
+        void host.execute(command, { origin }).then((outcome) => {
             const message = outcomeMessage(outcome);
             if (message !== null)
                 onStatus(message);
@@ -127,7 +128,7 @@ export function CommandDialogs({ host, state, focusedWindow, directoryApps, onSt
             onStatus(row.availability.reason);
             return;
         }
-        run(row.commandId, "keyboard");
+        run(row.command, "keyboard");
     }, [onStatus, run, setKeysOpen]);
     useLayoutEffect(() => {
         if (!keysOpen)
@@ -160,7 +161,7 @@ export function CommandDialogs({ host, state, focusedWindow, directoryApps, onSt
                                     } })] }, group.label)))] }) }), _jsx(Dialog, { open: commandLineOpen, onOpenChange: setCommandLineOpen, children: _jsxs(DialogContent, { container: dialog, className: "tourtois-command-palette", finalFocus: finalFocus, children: [_jsx(DialogTitle, { className: "sr-only", children: "Command palette" }), _jsxs("div", { className: "tourtois-command-palette-heading", children: [focusedApp
                                     ? renderIcon(focusedApp.roles, focusedApp.icon ?? undefined)
                                     : null, _jsx("span", { children: focusedTitle ?? "Commands" })] }), _jsx(Combobox, { activeTone: "primary", "aria-label": "Available commands", emptyMessage: "No matching commands", getKey: (command) => command.commandId, getLabel: (command) => command.title, getSearchText: (command) => {
-                                const app = appByCommandId.get(command.commandId);
+                                const app = paletteEntry(command)?.app;
                                 return `${command.title} ${command.category} ${command.description ?? ""} ${app?.name ?? ""} ${app ? `opens ${app.name}` : ""}`;
                             }, groupBy: (command) => {
                                 if (isFocusedCommand(command))
@@ -169,26 +170,17 @@ export function CommandDialogs({ host, state, focusedWindow, directoryApps, onSt
                                     return "Other apps";
                                 return "Workspace";
                             }, inputProps: { "aria-label": "Search commands" }, items: paletteRows, placeholder: ":", renderItem: (command) => (_jsxs("div", { className: "tourtois-command-palette-item", children: [_jsx("span", { className: "tourtois-command-palette-item-icon", children: (() => {
-                                            const app = appByCommandId.get(command.commandId);
-                                            if (app === undefined)
+                                            const entry = paletteEntry(command);
+                                            if (entry === undefined)
                                                 return null;
-                                            const declared = app.commands.find((entry) => (command.sourceId === appDirectorySourceId
-                                                ? directoryCommandId(app.surfaceId, entry.id)
-                                                : appCommandId(app.surfaceId, entry.id)) ===
-                                                command.commandId);
-                                            return renderIcon(app.roles, declared?.sigil ?? app.icon ?? undefined);
-                                        })() }), _jsx("span", { className: "tourtois-command-palette-item-title", children: command.title }), command.sourceId === appDirectorySourceId ? (appByCommandId.get(command.commandId)?.name !==
-                                        focusedApp?.name ? (_jsxs("small", { children: ["opens", " ", appByCommandId.get(command.commandId)?.name ?? "App"] })) : null) : null, (() => {
-                                        const app = appByCommandId.get(command.commandId);
-                                        const declared = app?.commands.find((entry) => [
-                                            appCommandId(app.surfaceId, entry.id),
-                                            directoryCommandId(app.surfaceId, entry.id),
-                                        ].includes(command.commandId));
+                                            return renderIcon(entry.app.roles, entry.declared?.sigil ?? entry.app.icon ?? undefined);
+                                        })() }), _jsx("span", { className: "tourtois-command-palette-item-title", children: command.title }), command.sourceId === appDirectorySourceId ? (paletteEntry(command)?.app.name !== focusedApp?.name ? (_jsxs("small", { children: ["opens ", paletteEntry(command)?.app.name ?? "App"] })) : null) : null, (() => {
+                                        const declared = paletteEntry(command)?.declared;
                                         return (_jsx("span", { className: "tourtois-command-palette-shortcut", children: commandKeycaps(command.commandId, active, mac, declared).map((key, index) => key === "then" ? (_jsx("span", { children: "then" }, `${key}-${String(index)}`)) : (_jsx("kbd", { className: "kbd kbd-sm", children: key }, `${key}-${String(index)}`))) }));
                                     })()] })), value: null, onValueChange: (_value, command) => {
                                 if (!command)
                                     return;
                                 setCommandLineOpen(false);
-                                run(command.commandId, "palette");
+                                run(command.command, "palette");
                             } }), _jsxs("div", { className: "tourtois-command-palette-footer", children: [_jsx("span", { className: "tourtois-command-palette-close-hint", children: "Esc to close" }), _jsxs("span", { className: "tourtois-command-palette-leader-hint", children: [_jsx("kbd", { className: "kbd kbd-sm", children: mac ? "⌘ K" : "Ctrl K" }), _jsx("span", { children: "then" }), _jsx("kbd", { className: "kbd kbd-sm", children: "?" }), _jsx("span", { children: "for all keys" })] })] })] }) })] }));
 }

package/dist/desktop/Desktop.d.ts

@@ -8,7 +8,6 @@ import { type DesktopGillTransport } from "./row-gill.js";
 export type DesktopProps = {
     phone: boolean;
     apps: WorkbenchDirectory["apps"];
-    inboxSurfaceId: string | null;
     launcherItems: readonly AppBarItem[];
     needsUpdate: NonNullable<WorkbenchDirectory["needsUpdate"]>;
     onAppSettings: (app: WorkbenchDirectory["apps"][number]) => void;

package/dist/desktop/Desktop.js

@@ -48,14 +48,18 @@ export function Desktop(props) {
             props.onOwner?.(null);
             current?.close();
         };
-    }, [
-        props.methods,
-        props.storage,
-        props.apps,
-        props.inboxSurfaceId,
-        props.onOwner,
-        retry,
-    ]);
+    }, [props.methods, props.storage, props.onOwner, retry]);
+    // The backend resolves the desktop against its own App catalog. One owner
+    // lives across directory polls; only a changed App set re-reads it.
+    const catalog = JSON.stringify(props.apps.map((app) => [app.surfaceId, app.releaseId, app.availability]));
+    const readCatalog = useRef(null);
+    useEffect(() => {
+        if (owner === null)
+            return;
+        if (readCatalog.current !== null && readCatalog.current !== catalog)
+            owner.invalidate();
+        readCatalog.current = catalog;
+    }, [owner, catalog]);
     return (_jsxs("div", { className: "tourtois-desktop", "data-desktop-bento": true, children: [error ? (_jsxs("p", { role: "alert", children: [error, " ", _jsx(Button, { variant: "ghost", size: "sm", onClick: () => {
                             setRetry((value) => value + 1);
                         }, children: "Retry" })] })) : null, !owner && !error ? _jsx("p", { role: "status", children: "Loading desktop\u2026" }) : null, owner ? _jsx(ArrangedDesktop, { ...props, owner: owner }) : null] }));

package/dist/desktop-client.d.ts

@@ -9,6 +9,8 @@ export type DesktopLayoutClient = Readonly<{
     };
     subscribe: (listener: () => void) => () => void;
     refresh: () => Promise<void>;
+    /** Re-read in the background; a failure shows through `refreshFailure`. */
+    invalidate: () => void;
     mutate: (method: DesktopMutation, input: WhistleJsonValue) => Promise<DesktopArrangeResult>;
     close: () => void;
 }>;

package/dist/desktop-client.js

@@ -85,10 +85,11 @@ export async function createDesktopLayoutClient({ storage, methods, }) {
         });
         return pending;
     };
-    const unsubscribe = watch.subscribe(() => {
-        // Handle watcher failures through the same idempotent state publisher.
+    // Handle background failures through the same idempotent state publisher.
+    const invalidate = () => {
         void refresh().catch(publishRefreshFailure);
-    });
+    };
+    const unsubscribe = watch.subscribe(invalidate);
     const close = () => {
         closed = true;
         retirePending?.();
@@ -116,6 +117,7 @@ export async function createDesktopLayoutClient({ storage, methods, }) {
             };
         },
         refresh,
+        invalidate,
         async mutate(method, input) {
             const result = desktopArrangeResultSchema.parse(await methods.call(method, JSON.stringify(input)));
             if (result.kind === "accepted" || result.code === "conflict")

package/dist/shell-host.js

@@ -243,6 +243,7 @@ export function createTourtoisShell(workbench) {
         focus: commands.focus,
         registerShellCommands: commands.registerShellCommands,
         registerDirectoryCommands: commands.registerDirectoryCommands,
+        appCommand: commands.appCommand,
         menu: commands.menu,
         snapshot: commands.snapshot,
         active: commands.active,

package/dist/status-bar.js

@@ -17,19 +17,21 @@ const statusIcons = {
  * the Computer picker, never a raised key. Caps' status-bar chip replaces
  * this composition when it ships.
  */
-const StatusBarButton = forwardRef(function StatusBarButton({ label, icon, count, pressed, expanded, ...props }, ref) {
-    return (_jsxs(Button, { ...props, ref: ref, variant: "ghost", size: "xs", className: "caps-status-bar-picker tourtois-status-chip", ...(pressed === undefined ? {} : { "aria-pressed": pressed }), ...(expanded === undefined ? {} : { "aria-expanded": expanded }), children: [icon, _jsx("span", { className: "caps-status-bar-picker-label tourtois-status-chip-label", children: label }), count] }));
+const StatusBarButton = forwardRef(function StatusBarButton({ label, icon, count, light, pressed, expanded, ...props }, ref) {
+    return (_jsxs(Button, { ...props, ref: ref, variant: "ghost", size: "xs", className: "caps-status-bar-picker tourtois-status-chip", ...(pressed === undefined ? {} : { "aria-pressed": pressed }), ...(expanded === undefined ? {} : { "aria-expanded": expanded }), children: [icon, light, _jsx("span", { className: "caps-status-bar-picker-label tourtois-status-chip-label", children: label }), count] }));
 });
 /** One App-declared status item, drawn by the shell as a flat status chip. */
 export function WindowStatusItem({ item, container, onAction, anchorFor, }) {
     const count = (item.kind === "button" || item.kind === "menu") &&
         item.count !== undefined &&
         item.count > 0 ? (_jsx(CountBadge, { count: item.count })) : null;
+    const light = item.kind === "button" &&
+        (item.tone !== undefined || item.busy === true) ? (_jsx(Status, { size: "compact", "aria-hidden": "true", tone: item.tone ?? "accent", motion: item.busy === true ? "pulse" : "none" })) : undefined;
     switch (item.kind) {
         case "text":
             return item.tone === undefined ? (_jsx(AppStatusItem, { role: "status", children: item.text })) : (_jsx(Status, { size: "compact", tone: item.tone, label: item.text }));
         case "button":
-            return (_jsx(StatusBarButton, { label: item.text, icon: item.icon === undefined ? undefined : statusIcons[item.icon], count: count, title: item.title ?? item.text, disabled: item.disabled, "aria-haspopup": item.opens, ...(item.expanded === undefined ? {} : { expanded: item.expanded }), onClick: (event) => {
+            return (_jsx(StatusBarButton, { label: item.text, icon: item.icon === undefined ? undefined : statusIcons[item.icon], count: count, light: light, title: item.title ?? item.text, disabled: item.disabled, "aria-haspopup": item.opens, ...(item.expanded === undefined ? {} : { expanded: item.expanded }), onClick: (event) => {
                     const anchor = anchorFor(event.currentTarget);
                     onAction(anchor === undefined
                         ? { itemId: item.id }

package/dist/useDirectoryCommands.d.ts

@@ -1,5 +1,5 @@
 import type { TourtoisAppSurfaceHost } from "./app-surface.js";
-import type { AppDirectoryApp } from "./app-launch.js";
+import { type AppDirectoryApp } from "./app-launch.js";
 import type { createAppWindowManager, AppLaunchDescriptor } from "./app-windows.js";
 /** Keep declared commands addressable before their App has mounted. */
 export declare function useDirectoryCommands({ host, directory, manager, launchFor, onFocus, onError, }: {

package/dist/useDirectoryCommands.js

@@ -1,26 +1,7 @@
 import { useEffect, useMemo, useRef } from "react";
-function waitForPaletteCommand(host, commandId) {
-    const isReady = () => host.active().palette.some((command) => command.commandId === commandId);
-    if (isReady())
-        return Promise.resolve();
-    return new Promise((resolve, reject) => {
-        const timeout = window.setTimeout(() => {
-            unsubscribe();
-            reject(new Error("The App did not register its declared command."));
-        }, 10_000);
-        const finish = () => {
-            window.clearTimeout(timeout);
-            unsubscribe();
-            resolve();
-        };
-        const check = () => {
-            if (isReady())
-                finish();
-        };
-        const unsubscribe = host.subscribe(check);
-        check();
-    });
-}
+import { waitForSurfaceCommand } from "./app-launch.js";
+import { appSurfaceCommandKey } from "@fungi.computer/nacre/command-host";
+import { sameWhistleCommand } from "@fungi.computer/whistle";
 /** Keep declared commands addressable before their App has mounted. */
 export function useDirectoryCommands({ host, directory, manager, launchFor, onFocus, onError, }) {
     const advertisedCommands = useMemo(() => directory.flatMap((installation) => installation.commands.map((command) => ({
@@ -56,9 +37,15 @@ export function useDirectoryCommands({ host, directory, manager, launchFor, onFo
             try {
                 await context.manager.open(launch);
                 context.onFocus(launch.windowId);
-                const runtimeCommandId = `${encodeURIComponent(surfaceId)}:${commandId}`;
-                await waitForPaletteCommand(host, runtimeCommandId);
-                const outcome = await host.execute(runtimeCommandId, {
+                const key = appSurfaceCommandKey({ surfaceId, commandId });
+                const registered = () => host
+                    .active()
+                    .palette.find((row) => sameWhistleCommand(row.command, key));
+                await waitForSurfaceCommand(host, () => registered() !== undefined);
+                const row = registered();
+                if (!row)
+                    throw new Error("The App did not register its declared command.");
+                const outcome = await host.execute(row.command, {
                     origin: "palette",
                 });
                 if (outcome.status === "handled")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fungi.computer/tourtois",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "author": "Levi <levi@technomancy.dev>",
   "description": "Tourtois: the trusted desktop shell for Oyster and Fungi, with host-supplied Settings sections",
   "type": "module",
@@ -73,19 +73,19 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@fungi.computer/agar": "0.4.0",
+    "@fungi.computer/agar": "0.5.0",
     "@fungi.computer/cairn": "0.1.0",
-    "@fungi.computer/caps": "0.3.1",
+    "@fungi.computer/caps": "0.4.0",
     "@fungi.computer/ear-tag": "0.1.0",
     "@fungi.computer/gills": "0.2.0",
     "@fungi.computer/maosaico": "0.1.0",
-    "@fungi.computer/parakeet": "0.4.0",
+    "@fungi.computer/parakeet": "0.5.0",
     "@fungi.computer/puffball": "0.2.0",
-    "@fungi.computer/shiitake": "0.5.0",
+    "@fungi.computer/shiitake": "0.6.0",
     "@fungi.computer/sigils": "0.2.0",
     "@fungi.computer/sprite": "0.2.0",
     "@fungi.computer/sprite-zdog": "0.2.0",
-    "@fungi.computer/whistle": "0.2.0",
+    "@fungi.computer/whistle": "0.3.0",
     "@tanstack/history": "1.162.1",
     "@tanstack/react-form": "1.33.2",
     "@tanstack/react-query": "5.102.8",
@@ -96,16 +96,16 @@
     "lucide-react": "0.460.0",
     "react-dom": "18.3.1",
     "zod": "4.4.3",
-    "@fungi.computer/nacre": "0.0.3"
+    "@fungi.computer/nacre": "0.1.0"
   },
   "peerDependencies": {
     "react": "^18.3.1 || ^19.2.0"
   },
   "devDependencies": {
-    "@fungi.computer/oyster": "0.5.0",
+    "@fungi.computer/oyster": "0.6.0",
     "@cloudflare/workers-types": "5.20260828.1",
     "@fungi.computer/forage": "0.2.0",
-    "@fungi.computer/mycelium": "0.2.2",
+    "@fungi.computer/mycelium": "0.2.3",
     "@ladle/react": "5.1.1",
     "@types/react": "18.3.3",
     "@vitejs/plugin-react": "6.1.1",