@rynx-ai/daemon 0.1.11-beta.2 → 0.1.11-beta.21

package/dist/control-deps.js

@@ -6,32 +6,73 @@
  */
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { listAgentSpecs, loadAgentSpec, rynxHome } from "@rynx-ai/core";
+import { listAgentSpecs, loadAgentSpec, rynxHome, scanLocalRuntimesInWorker, } from "@rynx-ai/core";
+import { listRuntimeModels } from "@rynx-ai/server";
 import { createEmulatorControlDeps } from "@rynx-ai/emulator";
 import { removeAgentSpec, writeAgentSpec } from "./agent-file.js";
-import { getCatalogSkill, installCatalogSkill, listCatalogSkills, readCatalogSkillFile, removeCatalogSkill, } from "./skills-catalog.js";
+import { getCatalogSkill, importLocalCatalogSkills, importCatalogSkillsFromArchive, installCatalogSkill, listCatalogSkills, readCatalogSkillFile, removeCatalogSkill, scanLocalCatalogSkillCandidates, } from "./skills-catalog.js";
 import { createSessionMeta, getSessionMeta, listSessionMetas, removeSessionMeta, setSessionTitle, } from "./session-meta-store.js";
 import { consumeControlLink } from "./control-link-store.js";
-export function buildControlDeps() {
+const RUNTIME_OPTIONS_CACHE_MS = 30_000;
+export function buildControlDeps(config) {
+    let runtimeOptionsCache;
+    let runtimeOptionsInFlight;
+    const listAgentRuntimeOptions = async (options = {}) => {
+        const now = Date.now();
+        if (!options.refresh && runtimeOptionsCache && runtimeOptionsCache.expiresAt > now) {
+            return runtimeOptionsCache.value;
+        }
+        if (!options.refresh && runtimeOptionsInFlight)
+            return runtimeOptionsInFlight;
+        const scan = async () => {
+            const runtimes = await scanLocalRuntimesInWorker();
+            const value = await Promise.all(runtimes.map(async (runtime) => {
+                return {
+                    id: runtime.id,
+                    name: runtime.displayName,
+                    binary: runtime.binary,
+                    ...(runtime.executablePath ? { executablePath: runtime.executablePath } : {}),
+                    ...(runtime.version ? { version: runtime.version } : {}),
+                    available: runtime.available,
+                    models: await listControlAgentModels(config, runtime.id),
+                };
+            }));
+            runtimeOptionsCache = { expiresAt: Date.now() + RUNTIME_OPTIONS_CACHE_MS, value };
+            return value;
+        };
+        runtimeOptionsInFlight = scan();
+        try {
+            return await runtimeOptionsInFlight;
+        }
+        finally {
+            runtimeOptionsInFlight = undefined;
+        }
+    };
     return {
         // ── declarative agents ───────────────────────────────────────────────
         listAgents: async () => (await listAgentSpecs()).map((spec) => ({
             id: spec.id,
             name: spec.name,
+            description: spec.description,
             runtime: spec.executor?.runtime,
-            model: spec.executor?.model,
+            ...(spec.executor?.model ? { model: spec.executor.model } : {}),
+            skillCount: spec.skills?.length ?? 0,
         })),
         getAgent: (id) => loadAgentSpec(id),
         writeAgent: (id, spec) => {
             writeAgentSpec(id, spec);
         },
         removeAgent: (id) => removeAgentSpec(id),
+        listAgentRuntimeOptions,
         // ── skills catalog ───────────────────────────────────────────────────
         listSkills: () => listCatalogSkills(),
         getSkill: (name) => getCatalogSkill(name),
         readSkillFile: (name, file) => readCatalogSkillFile(name, file),
         installSkill: (recipe) => installCatalogSkill(recipe),
         removeSkill: (name) => removeCatalogSkill(name),
+        scanLocalSkills: (runtime) => scanLocalCatalogSkillCandidates(runtime),
+        importLocalSkills: (runtime, keys) => importLocalCatalogSkills(runtime, keys),
+        importSkillArchive: (filename, contentBase64) => importCatalogSkillsFromArchive(filename, contentBase64),
         // ── emulator proxy (single seam: the emulator package owns the surface) ─
         emulator: createEmulatorControlDeps(),
         // ── control-plane sessions (meta persisted; status held by the server) ─
@@ -44,6 +85,48 @@ export function buildControlDeps() {
         tailLogs: (instanceId, lines) => tailLogs(instanceId, lines),
     };
 }
+/** Project a Runtime-native model catalog into the control-plane option shape. */
+export async function listControlAgentModels(config, runtime) {
+    const catalog = await listRuntimeModels(config, runtime);
+    return (catalog?.data ?? [])
+        .filter((model) => model.hidden !== true)
+        .map((model) => ({
+        id: model.model || model.id,
+        label: model.displayName || model.model || model.id,
+        ...(model.description ? { description: model.description } : {}),
+        ...(model.isDefault ? { isDefault: true } : {}),
+        ...(model.defaultReasoningEffort
+            ? { defaultReasoningEffort: model.defaultReasoningEffort }
+            : {}),
+        reasoningOptions: model.supportedReasoningEfforts?.length
+            ? model.supportedReasoningEfforts.map((effort) => ({
+                value: effort.reasoningEffort,
+                label: reasoningLabel(effort.reasoningEffort),
+                ...(effort.description ? { description: effort.description } : {}),
+            }))
+            : fallbackReasoningOptions(runtime, model.model || model.id),
+    }));
+}
+function fallbackReasoningOptions(runtime, model) {
+    const values = runtime === "claude"
+        ? model.toLowerCase().includes("opus")
+            ? ["low", "medium", "high", "xhigh"]
+            : ["low", "medium", "high"]
+        : ["none", "minimal", "low", "medium", "high", "xhigh"];
+    return values.map((value) => ({ value, label: reasoningLabel(value) }));
+}
+function reasoningLabel(value) {
+    return {
+        none: "None",
+        minimal: "Minimal",
+        low: "Low",
+        medium: "Medium",
+        high: "High",
+        xhigh: "Extra high",
+        max: "Max",
+        ultra: "Ultra",
+    }[value] ?? value;
+}
 /** Tail the daemon's merged pm2 logs, best-effort filtered by instance id. */
 async function tailLogs(instanceId, lines) {
     const dir = join(rynxHome(), "logs");

package/dist/control-link-store.js

@@ -1,5 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { db } from "./db.js";
+import { transaction } from "./sqlite.js";
 const DEFAULT_TTL_MS = 5 * 60_000;
 const MAX_TTL_MS = 15 * 60_000;
 /** Create a short-lived, one-use link into the generic session console. */
@@ -23,7 +24,7 @@ export function consumeControlLink(tokenInput) {
     if (!token || token.length > 512)
         return null;
     const now = new Date().toISOString();
-    const consume = db().transaction(() => {
+    const consume = transaction(db(), () => {
         const row = db()
             .prepare(`SELECT session_id
          FROM control_links
@@ -39,9 +40,9 @@ export function consumeControlLink(tokenInput) {
     return consume.immediate();
 }
 export function pruneControlLinks(now = new Date().toISOString()) {
-    return db()
+    return Number(db()
         .prepare("DELETE FROM control_links WHERE expires_at <= ? OR used_at IS NOT NULL")
-        .run(now).changes;
+        .run(now).changes);
 }
 function required(value, label) {
     const normalized = value?.trim();

package/dist/daemon-owner.js

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
 import { rynxHome } from "@rynx-ai/core";
-import Database from "better-sqlite3";
+import { hasSqlitePrimaryCode, SQLITE_BUSY, SQLITE_LOCKED } from "./sqlite.js";
 const LOCK_FILE = "daemon-owner.sqlite";
 const OWNER_FILE = "daemon-owner.json";
 /**
@@ -18,16 +19,15 @@ export async function acquireDaemonOwner(env = process.env) {
     const lockPath = path.join(home, LOCK_FILE);
     const ownerFile = path.join(home, OWNER_FILE);
     await mkdir(home, { recursive: true, mode: 0o700 });
-    const connection = new Database(lockPath, { timeout: 0 });
+    const connection = new DatabaseSync(lockPath, { timeout: 0 });
     try {
-        connection.pragma("busy_timeout = 0");
         connection.exec("BEGIN EXCLUSIVE");
         // Force this transaction to hold a write lock even on a brand-new file.
         connection.exec("CREATE TABLE IF NOT EXISTS daemon_owner_guard (id INTEGER PRIMARY KEY)");
     }
     catch (error) {
         connection.close();
-        if (hasCode(error, "SQLITE_BUSY") || hasCode(error, "SQLITE_LOCKED")) {
+        if (hasSqlitePrimaryCode(error, SQLITE_BUSY) || hasSqlitePrimaryCode(error, SQLITE_LOCKED)) {
             throw await ownerConflictError(home, ownerFile);
         }
         throw error;
@@ -99,6 +99,3 @@ function rollbackAndClose(connection) {
         connection.close();
     }
 }
-function hasCode(error, code) {
-    return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}

package/dist/daemon-server.d.ts

@@ -9,6 +9,9 @@ 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. */
@@ -25,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, preparePlugins, 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

@@ -11,19 +11,22 @@ import { createRequire } from "node:module";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import WebSocket from "ws";
-import { loadConfig, resolveExecutionSnapshot, rynxHome, sessionWorkspaceSnapshotSchema, } 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, MachineSessionServiceFailure, listRuntimeModels, RemoteRuntimeDispatcher, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceCoordinator, SessionEmulatorService, startServer, startDirectRuntimeServer, } from "@rynx-ai/server";
+import { createDaemonRuntimeHost, createDesktopFirstSessionBrowserHost, createRunnerSessionTerminalHost, createSessionRuntimeServices, DesktopBrowserHostAbsentError, DesktopBrowserHostRegistry, DirectRuntimeConnectionHub, DirectRuntimeBrowserInspectHostError, MachineSessionService, MachineSessionServiceFailure, RemoteRuntimeDispatcher, SessionBrowserService, SessionBrowserServiceError, SessionBrowserSurfaceCoordinator, SessionEmulatorService, startServer, startDirectRuntimeServer, } from "@rynx-ai/server";
+import { authorizeSessionPortalGrant, redeemSessionPortalTicket, } from "./session-portal-grant-store.js";
 import { APP_BROWSER_HOST_BOOTSTRAP_TYPE, AppBrowserHostSupervisor, parseAppBrowserHostLaunchConfig, } from "./app-browser-host-supervisor.js";
-import { buildControlDeps } from "./control-deps.js";
+import { buildControlDeps, listControlAgentModels } 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";
@@ -47,7 +50,7 @@ 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";
+import { sessionBelongsToPlugin, sessionRegistry } from "./session-meta-store.js";
 import { sessionPendingMessageStore } from "./session-pending-message-store.js";
 import { RemoteRuntimeAccessStore } from "./remote-runtime-access-store.js";
 import { DaemonRemoteRuntimeAdmin } from "./remote-runtime-admin.js";
@@ -66,17 +69,14 @@ 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;
-            },
-        }),
+        ...await resolveExecutionSnapshot(input),
         pluginSkills: snapshotEnabledPluginSkillSources(),
     };
 }
-async function resolveSessionWorkspace(projects, projectId, managedCwd) {
+async function resolveSessionWorkspace(projects, projectId, managedCwd, workspace) {
+    if (workspace) {
+        return sessionWorkspaceSnapshotSchema.parse(workspace);
+    }
     if (projectId) {
         const project = await projects.get(projectId);
         if (!project) {
@@ -131,7 +131,8 @@ function toMarketplaceItem(record) {
     };
 }
 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 }));
@@ -250,19 +251,31 @@ 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, preparePlugins, 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();
         const directConfig = directHostingSupported
             ? await loadDirectConfig()
             : undefined;
-        const control = buildControlDeps();
+        const control = buildControlDeps(appConfig);
         const installationIdentity = await loadOrCreateDaemonInstallationIdentity();
         const directEncryptionIdentity = directHostingSupported
             ? await loadOrCreateDaemonDirectRuntimeEncryptionIdentity()
@@ -286,6 +299,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 "semantic.session.interrupt.v1",
                 "semantic.session.agent-options.v1",
                 "semantic.session.launch-options.v2",
+                "semantic.session.execution-settings.v1",
                 "semantic.session.create.v1",
                 "semantic.session.fork.v1",
                 "semantic.session.message.v1",
@@ -335,6 +349,9 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
         }
         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
@@ -379,7 +396,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 },
                 sessionLaunch: {
                     resolve: async (selection) => {
-                        const workspace = await resolveSessionWorkspace(runtimeProjects, selection.projectId, selection.managedCwd);
+                        const workspace = await resolveSessionWorkspace(runtimeProjects, selection.projectId, selection.managedCwd, selection.workspace);
                         return {
                             workspace,
                             execution: await resolveSessionExecutionSnapshot({
@@ -387,9 +404,9 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                                 ...(selection.agent ? { agentName: selection.agent } : {}),
                                 ...(selection.config ? { spec: selection.config } : {}),
                                 ...((selection.provider || (!selection.agent && !selection.config))
-                                    ? { provider: selection.provider ?? appConfig.AGENT_RUNTIME }
+                                    ? { provider: selection.provider ?? appConfig.DEFAULT_RUNTIME }
                                     : {}),
-                                ...(selection.model ? { model: selection.model } : {}),
+                                ...(selection.model !== undefined ? { model: selection.model } : {}),
                                 ...(selection.reasoningEffort
                                     ? { reasoningEffort: selection.reasoningEffort }
                                     : {}),
@@ -398,7 +415,14 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                         };
                     },
                 },
+                sessionExecution: {
+                    update: async (input) => {
+                        await machineSessions.updateExecutionSettings(input);
+                    },
+                },
                 sessionFork: (input) => machineSessions.fork(input),
+                admissionOpen,
+                admissionReserve: reserveAdmission,
             }),
             startPluginRuntimes: pluginSupervisor.startPluginRuntimes.bind(pluginSupervisor),
             statusSnapshot: pluginSupervisor.statusSnapshot.bind(pluginSupervisor),
@@ -421,6 +445,8 @@ 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
@@ -432,6 +458,8 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 exists: async (sessionId) => Boolean(sessionRegistry.get(sessionId) ??
                     await sessionRuntimeServices.sessionStore.get(sessionId)),
             },
+        }, {
+            admissionReserve: reserveAdmission,
         });
         const sessionEmulators = control.emulator
             ? new SessionEmulatorService({
@@ -529,24 +557,30 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             forks: sessionForks,
             execution: {
                 runtime: sessionRuntimeServices.conversationRuntime,
-                resolve: ({ agent, provider, model, reasoningEffort, cwd }) => resolveSessionExecutionSnapshot({
+                resolve: ({ agent, provider, model, reasoningEffort, permissionPreset, cwd }) => resolveSessionExecutionSnapshot({
                     config: appConfig,
                     ...(agent ? { agentName: agent } : {}),
                     ...(provider ? { provider } : {}),
                     ...(model ? { model } : {}),
                     ...(reasoningEffort ? { reasoningEffort } : {}),
+                    ...(permissionPreset ? { permissionPreset } : {}),
                     cwd,
                 }),
+                listModels: (provider) => listControlAgentModels(appConfig, provider),
                 runner: sessionRuntimeServices.runnerManager,
             },
             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 registered = sessionRegistry.get(sessionId);
                 if (!registered ||
@@ -556,8 +590,95 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                 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: () => ({
@@ -566,6 +687,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),
@@ -591,30 +720,7 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
             },
             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({
@@ -691,6 +797,11 @@ export async function startRynxDaemonServer({ config, warn = defaultWarn, writeE
                     registry: desktopBrowserHosts,
                     daemonInstanceId,
                 },
+                sessionPortalAuthorization: {
+                    redeem: redeemSessionPortalTicket,
+                    authorize: authorizeSessionPortalGrant,
+                    ownsSession: sessionBelongsToPlugin,
+                },
             });
             baseShutdown = server.shutdown.bind(server);
             if (directConfig && directEncryptionIdentity) {
@@ -853,8 +964,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;

package/dist/db.d.ts

@@ -1,5 +1,5 @@
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
 /** Absolute path to the SQLite file (override via `RYNX_DB`, else `~/.rynx/rynx.db`). */
 export declare function dbPath(): string;
 /** Open (or reuse) the database at the current path, migrating + importing on first open. */
-export declare function db(): Database.Database;
+export declare function db(): DatabaseSync;