@rynx-ai/daemon 0.1.11-beta.1 → 0.1.11-beta.3

package/dist/daemon-server.d.ts

@@ -9,10 +9,16 @@ export declare function daemonActivityBlocksShutdown(activity: DaemonActivitySna
 export interface StartRynxDaemonServerOptions {
     config?: AppConfig;
     warn?: (message: string) => void;
+    /** Process-owner callback after every daemon resource and owner lease has
+     * shut down successfully. Library callers normally leave this unset. */
+    onShutdownComplete?: () => void;
     /** Test/deployment seam; failures roll back the already-listening server. */
     writeEndpoint?: (config: AppConfig, managementToken: string) => Promise<void>;
     /** Test seam for owner-lock failure injection. Production always uses the RYNX_HOME lease. */
     acquireOwner?: () => Promise<DaemonOwnerLease>;
+    /** Runs after the exclusive daemon-owner lock is acquired and before plugin
+     * records are loaded or runners are started. */
+    preparePlugins?: () => Promise<void>;
     /** Test/deployment seam for the always-available Direct Runtime socket. */
     loadDirectConfig?: () => Promise<DirectRuntimeConfig>;
     /** Test seam for listener lifecycle and bind failures. */
@@ -22,7 +28,7 @@ export interface StartRynxDaemonServerOptions {
     /** Test seam for the App-only embedded Chromium process supervisor. */
     createBrowserHostSupervisor?: (options: AppBrowserHostSupervisorOptions) => Pick<AppBrowserHostSupervisor, "ensureConnected" | "restart" | "stop">;
 }
-export declare function startRynxDaemonServer({ config, warn, writeEndpoint, acquireOwner, loadDirectConfig, startDirectServer, createChromeInspectionManager, createBrowserHostSupervisor, }?: StartRynxDaemonServerOptions): Promise<Awaited<ReturnType<typeof startServer>>>;
+export declare function startRynxDaemonServer({ config, warn, onShutdownComplete, writeEndpoint, acquireOwner, preparePlugins, loadDirectConfig, startDirectServer, createChromeInspectionManager, createBrowserHostSupervisor, }?: StartRynxDaemonServerOptions): Promise<Awaited<ReturnType<typeof startServer>>>;
 export declare function createSupervisedAppSessionBrowserHost(desktop: SessionBrowserHost, supervisor: Pick<AppBrowserHostSupervisor, "ensureConnected" | "restart">): SessionBrowserHost;
 /**
  * Resolve the authenticated semantic target inside its owning Runtime and

package/dist/daemon-server.js

@@ -6,26 +6,30 @@
  * session registry. Keeping that wiring here avoids a second app-specific fork.
  */
 import { randomBytes, randomUUID } from "node:crypto";
-import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
+import { mkdir, readFile, realpath, rename, rm, stat, writeFile } from "node:fs/promises";
 import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import WebSocket from "ws";
-import { loadConfig, rynxHome } from "@rynx-ai/core";
+import { CloseableAdmissionGate, loadConfig, resolveExecutionSnapshot, rynxHome, sessionWorkspaceSnapshotSchema, } from "@rynx-ai/core";
 import { LOCAL_MANAGEMENT_PROTOCOL, } from "@rynx-ai/protocol/control";
 import { REMOTE_RUNTIME_CORE_PROTOCOL } from "@rynx-ai/protocol/remote-runtime";
 import { RUNTIME_BROWSER_INSPECT_MAX_MESSAGE_BYTES, RUNTIME_BROWSER_INSPECT_SEMANTIC_CAPABILITY, } from "@rynx-ai/protocol/runtime-browser-inspect";
 import { RUNTIME_BROWSER_SURFACE_SEMANTIC_CAPABILITY } from "@rynx-ai/protocol/runtime-browser-surface";
 import { RUNTIME_EMULATOR_SURFACE_SEMANTIC_CAPABILITY } from "@rynx-ai/protocol/runtime-emulator-surface";
-import { createDaemonRuntimeHost, createDesktopFirstSessionBrowserHost, createRunnerSessionTerminalHost, createSessionRuntimeServices, DesktopBrowserHostAbsentError, DesktopBrowserHostRegistry, DirectRuntimeConnectionHub, DirectRuntimeBrowserInspectHostError, MachineSessionService, RemoteRuntimeDispatcher, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceCoordinator, SessionEmulatorService, startServer, startDirectRuntimeServer, } from "@rynx-ai/server";
+import { createDaemonRuntimeHost, createDesktopFirstSessionBrowserHost, createRunnerSessionTerminalHost, createSessionRuntimeServices, DesktopBrowserHostAbsentError, DesktopBrowserHostRegistry, DirectRuntimeConnectionHub, DirectRuntimeBrowserInspectHostError, MachineSessionService, MachineSessionServiceFailure, listRuntimeModels, RemoteRuntimeDispatcher, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceCoordinator, SessionEmulatorService, startServer, startDirectRuntimeServer, } from "@rynx-ai/server";
 import { APP_BROWSER_HOST_BOOTSTRAP_TYPE, AppBrowserHostSupervisor, parseAppBrowserHostLaunchConfig, } from "./app-browser-host-supervisor.js";
 import { buildControlDeps } from "./control-deps.js";
 import { createBrowserArtifactManagementService } from "./browser-artifact-management.js";
 import { createDaemonBuildStatus } from "./daemon-build-status.js";
+import { MaintenanceLeaseStore } from "./maintenance-lease.js";
 import { BrowserRunnerSessionContextProvider } from "./browser-runner-session-context.js";
+import { removeLegacyPluginSkillSnapshot, snapshotEnabledPluginSkillSources, } from "./plugin-skill-context.js";
+import { installedDaemonVersion } from "./entry-path.js";
 import { isChromeForTestingHostSupported } from "./chrome-for-testing-store.js";
 import { ChromeInspectionManager, } from "./chrome-inspection-manager.js";
 import { createHeadlessBrowserHost } from "./headless-browser-host.js";
+import { db } from "./db.js";
 import { acquireDaemonOwner } from "./daemon-owner.js";
 import { DaemonDirectRuntimeAuthenticator } from "./direct-runtime-authenticator.js";
 import { DurableEmbeddedBrowserProfileHost } from "./embedded-browser-profile-cleanup.js";
@@ -34,13 +38,15 @@ import { isDaemonDirectRuntimeHostingSupported, loadOrCreateDaemonDirectRuntimeE
 import { cleanupLegacySessions } from "./migrations/cleanup-legacy-sessions.js";
 import { createMaintenanceManagementService } from "./maintenance-management.js";
 import { PluginManagementService } from "./plugin-management-service.js";
+import { addPluginMarketplace, listPluginMarketplaces, refreshPluginMarketplace, removePluginMarketplace, } from "./plugin-marketplace.js";
 import { PluginSupervisor } from "./plugin-supervisor.js";
 import { pruneInactivePluginInstallations } from "./plugin-installer.js";
 import { runPluginCliCommand } from "./plugin-cli.js";
-import { getPlugin, isRunnablePluginRecord, listEnabledPlugins } from "./plugin-store.js";
-import { loadPlugins, resolveChannelInstances } from "./registry.js";
+import { listPlugins } from "./plugin-store.js";
 import { SqliteSessionLogStore } from "./session-log-store.js";
+import { SqliteSessionForkStore } from "./session-fork-store.js";
 import { SqliteSessionResourceStore } from "./session-resource-store.js";
+import { createSessionFallbackWorkspace, discardSessionFallbackWorkspace, } from "./session-fallback-workspace.js";
 import { SessionBrowserCapabilityStore } from "./session-browser-capability-store.js";
 import { SqliteSessionEmulatorBindingStore } from "./session-emulator-binding-store.js";
 import { sessionRegistry } from "./session-meta-store.js";
@@ -52,6 +58,7 @@ import { DaemonRuntimeConnectionManager } from "./remote-runtime-connection-mana
 import { DaemonRuntimeTargetControl } from "./remote-runtime-target-control.js";
 import { RemoteRuntimeTargetStore } from "./remote-runtime-target-store.js";
 import { ProviderCliService } from "./provider-cli-service.js";
+import { SqliteRuntimeProjectStore } from "./runtime-project-store.js";
 const PLUGIN_CLI_OUTPUT_MAX_BYTES = 256 * 1024;
 const BROWSER_INSPECT_OPEN_TIMEOUT_MS = 10_000;
 const BROWSER_INSPECT_CLOSE_TIMEOUT_MS = 1_000;
@@ -59,8 +66,78 @@ const BROWSER_INSPECT_MAX_QUEUED_BYTES = 32 * 1024 * 1024;
 const DIRECT_RUNTIME_HOSTING_UNSUPPORTED = "Direct Runtime hosting is supported only on macOS and Linux until protected server-key storage is available on other operating systems";
 const require = createRequire(import.meta.url);
 const DAEMON_PACKAGE_VERSION = readDaemonPackageVersion();
+async function resolveSessionExecutionSnapshot(input) {
+    return {
+        ...await resolveExecutionSnapshot({
+            ...input,
+            resolveDefaultModel: async (provider) => {
+                const models = await listRuntimeModels(input.config, provider);
+                return models?.data.find((candidate) => candidate.isDefault)?.model;
+            },
+        }),
+        pluginSkills: snapshotEnabledPluginSkillSources(),
+    };
+}
+async function resolveSessionWorkspace(projects, projectId, managedCwd, workspace) {
+    if (workspace) {
+        return sessionWorkspaceSnapshotSchema.parse(workspace);
+    }
+    if (projectId) {
+        const project = await projects.get(projectId);
+        if (!project) {
+            throw new MachineSessionServiceFailure("not_found", "project not found");
+        }
+        await assertWorkspaceDirectories(project.directories);
+        return sessionWorkspaceSnapshotSchema.parse({
+            cwd: project.primary,
+            allowedDirs: [
+                project.primary,
+                ...project.directories.filter((directory) => directory !== project.primary),
+            ],
+        });
+    }
+    if (managedCwd) {
+        let canonical;
+        try {
+            canonical = await realpath(managedCwd);
+            await assertWorkspaceDirectories([canonical]);
+        }
+        catch (error) {
+            if (error instanceof MachineSessionServiceFailure)
+                throw error;
+            throw new MachineSessionServiceFailure("failed_precondition", "Session working directory is unavailable");
+        }
+        return sessionWorkspaceSnapshotSchema.parse({
+            cwd: canonical,
+            allowedDirs: [canonical],
+        });
+    }
+    return await createSessionFallbackWorkspace();
+}
+async function assertWorkspaceDirectories(directories) {
+    try {
+        await Promise.all(directories.map(async (directory) => {
+            if (!(await stat(directory)).isDirectory())
+                throw new Error(directory);
+        }));
+    }
+    catch {
+        throw new MachineSessionServiceFailure("failed_precondition", "one or more Project directories are unavailable");
+    }
+}
+function toMarketplaceItem(record) {
+    return {
+        id: record.marketplaceId,
+        source: record.sourceType,
+        builtIn: record.builtIn,
+        plugins: record.catalog.plugins.map((plugin) => ({ id: plugin.id })),
+        resolvedRevision: record.resolvedRevision,
+        refreshedAt: record.refreshedAt,
+    };
+}
 export function daemonActivityBlocksShutdown(activity) {
-    return activity.runningTurns > 0 || activity.pendingInteractions > 0;
+    return activity.runningTurns > 0
+        || activity.pendingInteractions > 0;
 }
 function defaultWarn(message) {
     console.warn(JSON.stringify({ level: "warn", type: "channel-registry", msg: message }));
@@ -179,11 +256,24 @@ async function removeControlEndpointForCurrentProcess() {
         // Best effort only; stale endpoint files are ignored by the client fallback.
     }
 }
-export async function startRynxDaemonServer({ config, warn = defaultWarn, writeEndpoint = writeControlEndpoint, acquireOwner = acquireDaemonOwner, loadDirectConfig = loadDirectRuntimeConfig, startDirectServer = startDirectRuntimeServer, createChromeInspectionManager = (options) => ChromeInspectionManager.create(options), createBrowserHostSupervisor = (options) => new AppBrowserHostSupervisor(options), } = {}) {
+export async function startRynxDaemonServer({ config, warn = defaultWarn, onShutdownComplete, writeEndpoint = writeControlEndpoint, acquireOwner = acquireDaemonOwner, preparePlugins, loadDirectConfig = loadDirectRuntimeConfig, startDirectServer = startDirectRuntimeServer, createChromeInspectionManager = (options) => ChromeInspectionManager.create(options), createBrowserHostSupervisor = (options) => new AppBrowserHostSupervisor(options), } = {}) {
     const owner = await acquireOwner();
     let ownerManagedByServer = false;
     try {
+        await preparePlugins?.();
         const appConfig = config ?? loadConfig();
+        const admissionGate = new CloseableAdmissionGate();
+        let shutdownAccepted = false;
+        const maintenanceLease = new MaintenanceLeaseStore({
+            // Expiry restores the gate primitive for a process that outlives its
+            // upgrader. The independent accepted-shutdown fence below still prevents
+            // new work after an irreversible server shutdown has begun.
+            onExpired: () => admissionGate.reopen(),
+        });
+        const admissionOpen = () => !shutdownAccepted && !maintenanceLease.isActive();
+        const reserveAdmission = () => !admissionOpen()
+            ? undefined
+            : admissionGate.tryReserve();
         const appBrowserHostLaunch = parseAppBrowserHostLaunchConfig();
         const directHostingSupported = isDaemonDirectRuntimeHostingSupported();
         const runtimeBrowserSupported = appBrowserHostLaunch !== undefined || isChromeForTestingHostSupported();
@@ -215,11 +305,13 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 "semantic.session.agent-options.v1",
                 "semantic.session.launch-options.v2",
                 "semantic.session.create.v1",
+                "semantic.session.fork.v1",
                 "semantic.session.message.v1",
                 "semantic.session.resources.v1",
                 "semantic.session.message-queue.v1",
                 "semantic.session.delete.v1",
                 "semantic.session.interaction.v1",
+                "semantic.project.manage.v1",
                 "semantic.provider-cli.status.v1",
                 ...(runtimeBrowserSupported ? ["semantic.browser.v1"] : []),
                 ...(runtimeBrowserSupported && directHostingSupported
@@ -259,8 +351,11 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
         catch (error) {
             warn(`plugin package cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        const pluginSupervisor = new PluginSupervisor(listEnabledPlugins(), {
+        const pluginSupervisor = new PluginSupervisor(listPlugins(), {
             daemonInstanceId,
+            productVersion: controlEndpointDistributionMetadata().productVersion,
+            cliVersion: boundedEnvironmentMetadata(process.env.RYNX_CLI_VERSION, 128)
+                ?? installedDaemonVersion(),
             log: (entry) => {
                 const output = entry.level === "error"
                     ? console.error
@@ -270,39 +365,14 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 output(JSON.stringify(entry));
             },
         });
-        const pluginManagement = new PluginManagementService();
+        const pluginManagement = new PluginManagementService(undefined, {
+            supervisor: pluginSupervisor,
+        });
         const browserArtifactManagement = createBrowserArtifactManagementService();
         const maintenanceManagement = createMaintenanceManagementService({
             codexStorePath: appConfig.AGENT_SESSION_STORE_PATH,
         });
-        await loadPlugins(pluginSupervisor, warn);
         logLegacyCleanup(appConfig);
-        const reloadPluginRuntime = async (pluginId) => {
-            const record = getPlugin(pluginId);
-            if (!record)
-                throw new Error(`plugin "${pluginId}" is not installed`);
-            if (!record.enabled)
-                throw new Error(`plugin "${pluginId}" is disabled`);
-            if (!isRunnablePluginRecord(record)) {
-                throw new Error(`plugin "${pluginId}" must be reinstalled before its runtime can start`);
-            }
-            const status = await pluginSupervisor.reloadPluginRuntime(record);
-            await loadPlugins(pluginSupervisor, warn);
-            return { pluginId, status };
-        };
-        const ensurePluginRuntime = async (pluginId) => {
-            const record = getPlugin(pluginId);
-            if (!record)
-                throw new Error(`plugin "${pluginId}" is not installed`);
-            if (!record.enabled)
-                throw new Error(`plugin "${pluginId}" is disabled`);
-            if (!isRunnablePluginRecord(record)) {
-                throw new Error(`plugin "${pluginId}" must be reinstalled before its runtime can start`);
-            }
-            const status = await pluginSupervisor.ensurePluginRuntime(record);
-            await loadPlugins(pluginSupervisor, warn);
-            return { pluginId, status };
-        };
         const invokePluginCli = async ({ pluginId, args, stdin }, { signal }) => {
             const result = await runPluginCliCommand(pluginId, args, {
                 stdio: "pipe",
@@ -310,14 +380,6 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 captureOutputBytes: PLUGIN_CLI_OUTPUT_MAX_BYTES,
                 signal,
             });
-            if (result.code === 0) {
-                const reload = result.effects.some((effect) => effect.effect === "runtime.reload");
-                const ensure = result.effects.some((effect) => effect.effect === "runtime.ensure");
-                if (reload)
-                    await reloadPluginRuntime(pluginId);
-                else if (ensure)
-                    await ensurePluginRuntime(pluginId);
-            }
             const output = result.output;
             return {
                 code: result.code,
@@ -326,6 +388,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 truncated: Boolean(output?.stdoutTruncated || output?.stderrTruncated),
             };
         };
+        let machineSessions;
         const pluginRuntime = {
             bindHostServices: (services) => pluginSupervisor.bindHostServices({
                 ...services,
@@ -335,10 +398,32 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                     publicKey: installationIdentity.publicKey,
                     sign: installationIdentity.sign,
                 },
+                sessionLaunch: {
+                    resolve: async (selection) => {
+                        const workspace = await resolveSessionWorkspace(runtimeProjects, selection.projectId, selection.managedCwd, selection.workspace);
+                        return {
+                            workspace,
+                            execution: await resolveSessionExecutionSnapshot({
+                                config: appConfig,
+                                ...(selection.agent ? { agentName: selection.agent } : {}),
+                                ...(selection.config ? { spec: selection.config } : {}),
+                                ...((selection.provider || (!selection.agent && !selection.config))
+                                    ? { provider: selection.provider ?? appConfig.DEFAULT_RUNTIME }
+                                    : {}),
+                                ...(selection.model ? { model: selection.model } : {}),
+                                ...(selection.reasoningEffort
+                                    ? { reasoningEffort: selection.reasoningEffort }
+                                    : {}),
+                                cwd: workspace.cwd,
+                            }),
+                        };
+                    },
+                },
+                sessionFork: (input) => machineSessions.fork(input),
+                admissionOpen,
+                admissionReserve: reserveAdmission,
             }),
             startPluginRuntimes: pluginSupervisor.startPluginRuntimes.bind(pluginSupervisor),
-            reloadPluginRuntime,
-            ensurePluginRuntime,
             statusSnapshot: pluginSupervisor.statusSnapshot.bind(pluginSupervisor),
             dispose: pluginSupervisor.dispose.bind(pluginSupervisor),
         };
@@ -346,6 +431,8 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
         const directConnections = new DirectRuntimeConnectionHub();
         const sessionLog = new SqliteSessionLogStore();
         const sessionResources = new SqliteSessionResourceStore();
+        const sessionForks = new SqliteSessionForkStore();
+        const runtimeProjects = new SqliteRuntimeProjectStore();
         const providerClis = new ProviderCliService();
         const sessionBrowserCapabilities = new SessionBrowserCapabilityStore();
         const durableDesktopBrowserHost = new DurableEmbeddedBrowserProfileHost(desktopBrowserHosts, { warn });
@@ -357,16 +444,21 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             config: appConfig,
             sessionLog,
             sessionContextProvider: browserRunnerSessionContexts,
+            admissionOpen,
+            admissionReserve: reserveAdmission,
             onMirrorError: (error, sessionId) => warn(`Session mirror failed for ${sessionId}: ${error instanceof Error ? error.message : String(error)}`),
         });
+        const sessionBrowserHost = appBrowserHostSupervisor
+            ? createSupervisedAppSessionBrowserHost(durableDesktopBrowserHost, appBrowserHostSupervisor)
+            : createDesktopFirstSessionBrowserHost(durableDesktopBrowserHost, createHeadlessBrowserHost());
         const sessionBrowsers = new SessionBrowserService({
-            host: appBrowserHostSupervisor
-                ? createSupervisedAppSessionBrowserHost(durableDesktopBrowserHost, appBrowserHostSupervisor)
-                : createDesktopFirstSessionBrowserHost(durableDesktopBrowserHost, createHeadlessBrowserHost()),
+            host: sessionBrowserHost,
             sessions: {
                 exists: async (sessionId) => Boolean(sessionRegistry.get(sessionId) ??
                     await sessionRuntimeServices.sessionStore.get(sessionId)),
             },
+        }, {
+            admissionReserve: reserveAdmission,
         });
         const sessionEmulators = control.emulator
             ? new SessionEmulatorService({
@@ -422,14 +514,35 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                     sessionEmulators?.cleanupSession(sessionId),
                 ]);
             },
-            afterDelete: (sessionId) => {
+            afterDelete: async (sessionId) => {
                 sessionBrowserCapabilities.revoke(sessionId);
+                removeLegacyPluginSkillSnapshot(sessionId);
+                await sessionRuntimeServices.sessionStore.delete(sessionId);
             },
         };
-        const machineSessions = new MachineSessionService({
+        const deletedSessions = db()
+            .prepare("SELECT session_id AS sessionId FROM session_snapshot_cleanup ORDER BY session_id")
+            .all();
+        for (const { sessionId } of deletedSessions) {
+            try {
+                await Promise.all([
+                    sessionBrowsers.cleanupSession(sessionId),
+                    sessionEmulators?.cleanupSession(sessionId),
+                ]);
+                sessionResources.deleteSession(sessionId);
+                removeLegacyPluginSkillSnapshot(sessionId);
+                await sessionRuntimeServices.sessionStore.delete(sessionId);
+                db().prepare("DELETE FROM session_snapshot_cleanup WHERE session_id = ?").run(sessionId);
+            }
+            catch (error) {
+                warn(`Legacy Session artifact cleanup will retry for ${sessionId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        machineSessions = new MachineSessionService({
             registry: sessionRegistry,
             log: sessionLog,
             events: sessionRuntimeServices.sessionBus,
+            publishEvent: sessionRuntimeServices.publishSessionEvent,
             runtimeState: sessionRuntimeServices.sessionRuntimeIndex,
             interruption: {
                 interrupt: (sessionId) => sessionRuntimeServices.runnerManager.interruptLiveSession(sessionId),
@@ -440,29 +553,129 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             },
             pendingMessages: sessionPendingMessageStore,
             resources: sessionResources,
+            forks: sessionForks,
             execution: {
                 runtime: sessionRuntimeServices.conversationRuntime,
+                resolve: ({ agent, provider, model, reasoningEffort, cwd }) => resolveSessionExecutionSnapshot({
+                    config: appConfig,
+                    ...(agent ? { agentName: agent } : {}),
+                    ...(provider ? { provider } : {}),
+                    ...(model ? { model } : {}),
+                    ...(reasoningEffort ? { reasoningEffort } : {}),
+                    cwd,
+                }),
                 runner: sessionRuntimeServices.runnerManager,
-                sessionStore: sessionRuntimeServices.sessionStore,
             },
+            workspace: {
+                resolve: (projectId) => resolveSessionWorkspace(runtimeProjects, projectId),
+                discardUnbound: discardSessionFallbackWorkspace,
+            },
+        }, {
+            admissionOpen,
+            admissionReserve: reserveAdmission,
         });
         const directAuthenticator = new DaemonDirectRuntimeAuthenticator(installationIdentity, remoteRuntime, remoteRuntimeAccess);
         const sessionTerminals = createRunnerSessionTerminalHost({
             runnerManager: sessionRuntimeServices.runnerManager,
+            admissionReserve: reserveAdmission,
             resolveLiveSession: async (sessionId) => {
-                const bound = await sessionRuntimeServices.sessionStore.get(sessionId);
                 const registered = sessionRegistry.get(sessionId);
-                const cwd = bound?.cwd ?? registered?.config?.osEnv?.cwd;
-                if ((!bound && !registered) ||
-                    !cwd ||
+                if (!registered ||
                     !sessionRuntimeServices.runnerManager.hasLiveSession(sessionId)) {
                     return undefined;
                 }
-                return { cwd };
+                return { cwd: registered.workspace.cwd };
             },
         });
-        let shutdownAccepted = false;
         let requestServerShutdown;
+        let shutdownAttempt;
+        let shutdownAttemptLeaseToken;
+        const shutdownIfIdle = (maintenanceLeaseToken) => {
+            if (maintenanceLease.isActive()) {
+                if (!maintenanceLeaseToken || !maintenanceLease.isHeldBy(maintenanceLeaseToken)) {
+                    return Promise.reject(new Error("a different maintenance lease is already active"));
+                }
+                // The previous daemon may have persisted the lease and exited after
+                // its 202 response was lost. A replacement process holding the same
+                // token must perform its own close/drain/shutdown; returning accepted
+                // without scheduling this PID would strand the updater waiting for a
+                // process that can never exit.
+            }
+            if (shutdownAccepted) {
+                if (maintenanceLeaseToken) {
+                    maintenanceLease.acquire(maintenanceLeaseToken);
+                    return Promise.resolve({
+                        outcome: "accepted",
+                        maintenanceLease: "active",
+                    });
+                }
+                return Promise.resolve({ outcome: "accepted" });
+            }
+            if (shutdownAttempt) {
+                if (maintenanceLeaseToken === shutdownAttemptLeaseToken) {
+                    return shutdownAttempt;
+                }
+                return Promise.reject(new Error("another idle shutdown check is already in progress"));
+            }
+            shutdownAttemptLeaseToken = maintenanceLeaseToken;
+            const attempt = (async () => {
+                await admissionGate.closeAndDrain();
+                const runtimeActivity = sessionRuntimeServices.sessionRuntimeIndex.activitySnapshot();
+                const activity = {
+                    ...runtimeActivity,
+                    // A terminal submission keeps its own admission reservation until the
+                    // first response or native rotation is visible. Failed process-tree
+                    // cleanup releases the reservation but remains pinned here, so an
+                    // idle check returns busy instead of hanging or killing hidden work.
+                    runningTurns: runtimeActivity.runningTurns
+                        + sessionRuntimeServices.runnerManager.pendingTerminalInputCount(),
+                    activeTerminals: sessionTerminals.activeTerminalCount(),
+                    activeBrowsers: sessionBrowsers.activeBrowserCount(),
+                };
+                if (daemonActivityBlocksShutdown(activity)) {
+                    admissionGate.reopen();
+                    return { outcome: "busy", activity };
+                }
+                const shutdown = requestServerShutdown;
+                if (!shutdown) {
+                    admissionGate.reopen();
+                    throw new Error("idle daemon shutdown was requested before server lifecycle was ready");
+                }
+                const acquiredLease = maintenanceLeaseToken
+                    ? maintenanceLease.acquire(maintenanceLeaseToken)
+                    : false;
+                shutdownAccepted = true;
+                try {
+                    void shutdown().catch((error) => {
+                        shutdownAccepted = false;
+                        if (acquiredLease && maintenanceLeaseToken) {
+                            maintenanceLease.release(maintenanceLeaseToken);
+                        }
+                        admissionGate.reopen();
+                        warn(`idle daemon shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
+                    });
+                }
+                catch (error) {
+                    shutdownAccepted = false;
+                    if (acquiredLease && maintenanceLeaseToken) {
+                        maintenanceLease.release(maintenanceLeaseToken);
+                    }
+                    admissionGate.reopen();
+                    throw error;
+                }
+                return maintenanceLeaseToken
+                    ? { outcome: "accepted", maintenanceLease: "active" }
+                    : { outcome: "accepted" };
+            })();
+            shutdownAttempt = attempt;
+            void attempt.finally(() => {
+                if (shutdownAttempt === attempt) {
+                    shutdownAttempt = undefined;
+                    shutdownAttemptLeaseToken = undefined;
+                }
+            }).catch(() => undefined);
+            return attempt;
+        };
         const daemonManagement = {
             managementToken,
             identity: () => ({
@@ -471,6 +684,14 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 publicKey: installationIdentity.publicKey,
             }),
             buildStatus: daemonBuildStatus,
+            releaseMaintenanceLease: (token) => ({
+                outcome: (() => {
+                    const outcome = maintenanceLease.release(token);
+                    if (outcome === "released")
+                        admissionGate.reopen();
+                    return outcome;
+                })(),
+            }),
             pluginManagement: {
                 listPlugins: () => pluginManagement.list(),
                 setPluginEnabled: (pluginId, enabled) => pluginManagement.setEnabled(pluginId, enabled),
@@ -478,34 +699,25 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 prepareInstallation: (input, context) => pluginManagement.prepareInstallation(input, context),
                 commitInstallation: (token, input, context) => pluginManagement.commitInstallation(token, input, context),
                 cancelPreparation: (token) => pluginManagement.cancelPreparation(token),
+                settingsUi: (pluginId) => pluginManagement.settingsUi(pluginId),
+                settingsUiAsset: (pluginId, assetGeneration, assetPath) => pluginManagement.settingsUiAsset(pluginId, assetGeneration, assetPath),
+                callSettings: (pluginId, generation, method, params, context) => pluginManagement.callSettings(pluginId, generation, method, params, context),
                 dispose: () => pluginManagement.dispose(),
             },
+            pluginMarketplaces: {
+                list: () => listPluginMarketplaces().map(toMarketplaceItem),
+                add: async (input, context) => toMarketplaceItem(await addPluginMarketplace(input.source, {
+                    ...(input.alias ? { alias: input.alias } : {}),
+                    signal: context.signal,
+                })),
+                refresh: async (id, context) => toMarketplaceItem(await refreshPluginMarketplace(id, {
+                    signal: context.signal,
+                })),
+                remove: (id) => removePluginMarketplace(id),
+            },
             browserArtifacts: browserArtifactManagement,
             maintenance: maintenanceManagement,
-            shutdownIfIdle: () => {
-                if (shutdownAccepted)
-                    return { outcome: "accepted" };
-                const activity = {
-                    ...sessionRuntimeServices.sessionRuntimeIndex.activitySnapshot(),
-                    activeTerminals: sessionTerminals.activeTerminalCount(),
-                    activeBrowsers: sessionBrowsers.activeBrowserCount(),
-                };
-                if (daemonActivityBlocksShutdown(activity)) {
-                    return { outcome: "busy", activity };
-                }
-                shutdownAccepted = true;
-                const shutdown = requestServerShutdown;
-                if (!shutdown) {
-                    shutdownAccepted = false;
-                    throw new Error("idle daemon shutdown was requested before server lifecycle was ready");
-                }
-                // Start admission fences in this event-loop turn, before another
-                // request or Direct dispatch can be accepted.
-                void shutdown().catch((error) => {
-                    warn(`idle daemon shutdown failed: ${error instanceof Error ? error.message : String(error)}`);
-                });
-                return { outcome: "accepted" };
-            },
+            shutdownIfIdle,
             invokePluginCli,
         };
         const remoteRuntimeDispatcher = new RemoteRuntimeDispatcher({
@@ -516,6 +728,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             terminals: sessionTerminals,
             browsers: sessionBrowsers,
             providerClis,
+            projects: runtimeProjects,
             onError: (error) => warn(`Remote Runtime dispatch failed: ${error instanceof Error ? error.message : String(error)}`),
         });
         const remoteRuntimeAdmin = directConfig && directEncryptionIdentity
@@ -552,7 +765,6 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             };
             server = await startServer({
                 config: appConfig,
-                loadInstances: () => resolveChannelInstances(warn),
                 control,
                 sessionLog,
                 sessionRegistry,
@@ -564,6 +776,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 runtimeTargetControl,
                 runtimeConnectionResolver: runtimeConnectionManager,
                 localSessionResources: machineSessions,
+                localMachineSessions: machineSessions,
                 providerClis,
                 sessionEmulators,
                 sessionLifecycle: sessionResourceLifecycle,
@@ -743,8 +956,10 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                     // A failed resource shutdown may leave plugin transports alive. Keep
                     // the process-scoped owner lease in that fail-closed state; it will be
                     // released by the OS when the process exits.
-                    if (shutdownComplete)
+                    if (shutdownComplete) {
                         await owner.release();
+                        onShutdownComplete?.();
+                    }
                 }
             })();
             return shutdownPromise;