@maudecode/talaria-web 1.17.2 → 1.19.0

package/dist/runtime.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { pinnedFetch, systemDnsLookup } from './http/pinned.js';
-import { mkdirSync, readFileSync } from 'node:fs';
+import { mkdirSync, readdirSync, readFileSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { AuthStore } from './auth/store.js';
 import { OidcService } from './auth/oidc.js';
@@ -9,6 +9,8 @@ import { PresenceLeases, RelayService } from './sessions/relay.js';
 import { CliSessionSource } from './sessions/cli-sessions.js';
 import { ClaudeCodeSessionSource, claudeCodeProjectsDir } from './sessions/claude-code.js';
 import { GatewayWatcherRegistry } from './sessions/gateway-watcher.js';
+import { GatewaySessions, gatewayStreamVisible } from './sessions/gateway-sessions.js';
+import { readImportableAgentSessionRowsAsync } from './sessions/state-db.js';
 import { CompletionDrain } from './sessions/completions.js';
 import { BackgroundActivity, BackgroundTaskStore } from './sessions/background-tasks.js';
 import { HygieneTicker } from './tools/hygiene.js';
@@ -22,10 +24,12 @@ import { displayBotName, pyBool, SettingsStore } from './settings.js';
 import { AssetCache, SpaShell } from './spa.js';
 import { StartupGate } from './startup.js';
 import { SessionStore } from './sessions/store.js';
+import { JsonStorage } from './sessions/storage/json.js';
 import { DraftStore } from './sessions/drafts.js';
 import { SessionEventBus } from './sessions/events.js';
 import { ShareStore } from './sessions/shares.js';
-import { SessionService } from './sessions/service.js';
+import { ensureAgentRuntimeCurrent, HttpFailure, SessionService } from './sessions/service.js';
+import { recoveryStampingSince } from './sessions/recovery.js';
 import { ProjectStore } from './projects.js';
 import { WorkspaceRegistry } from './workspace/workspaces.js';
 import { resolvePathLikePython } from './workspace/paths.js';
@@ -34,22 +38,24 @@ import { basename, delimiter, dirname, join } from 'node:path';
 import { GitRunner, GitWorkspaceError, pathsOverlap } from './workspace/git.js';
 import { RollbackStore } from './workspace/rollback.js';
 import { UploadInbox } from './workspace/upload.js';
+import { EscapeGrants } from './workspace/escape.js';
 import { TurnRunner } from './sessions/turn.js';
 import { SessionChannels, StreamRegistry } from './sessions/streams.js';
 import { PendingPrompts } from './sessions/pending.js';
-import { RunJournal } from './sessions/journal.js';
 import { StreamSlots } from './api/sse-routes.js';
 import { AgentConfig, coerceProviderCostBudgetValue, dict as asDict, parseProviderQualifiedModel } from './config/agent-config.js';
 import { ProviderCatalog } from './providers/catalog.js';
-import { ProfileService } from './profiles/profiles.js';
+import { containedProfileHome, escapedProfileMessage, ProfileError, ProfileService } from './profiles/profiles.js';
 import { Onboarding } from './onboarding.js';
 import { SkillsService } from './tools/skills.js';
 import { McpService } from './tools/mcp.js';
 import { WindowLimiter } from './api/tools-router.js';
 import { CronService } from './tools/crons.js';
 import { KanbanService } from './tools/kanban.js';
+import { DashboardPlugins } from './tools/dashboard-plugins.js';
 import { ExtensionService } from './tools/extensions.js';
-import { dashboardStatus } from './tools/health.js';
+import { dashboardStatus, gatewayRestartBlockers } from './tools/health.js';
+import { GatewayRestartQueue, restartGateway } from './tools/gateway-restart.js';
 import { TerminalRegistry } from './tools/terminal.js';
 export function packageVersion() {
     try {
@@ -59,40 +65,44 @@ export function packageVersion() {
         return undefined;
     }
 }
-export function createDeps(opts) {
+export async function createDeps(opts) {
     const log = opts.log ?? ((line) => { console.log(line); });
     const config = loadConfig(opts);
     const env = config.env;
     mkdirSync(config.stateDir, { recursive: true });
     mkdirSync(config.sessionDir, { recursive: true });
-    const settings = new SettingsStore({ file: config.settingsFile, env, stateDir: config.stateDir, defaultWorkspace: config.defaultWorkspace, botName: config.botName, log });
     const now = opts.now ?? (() => Date.now() / 1000);
-    const passkeys = new PasskeyStore(config.stateDir, now);
+    const storage = opts.storage?.(config) ?? createStorage(config, now, (name) => profileHome(name));
+    const settings = new SettingsStore({ documents: storage.documents, env, stateDir: config.stateDir, defaultWorkspace: config.defaultWorkspace, botName: config.botName, log });
+    await settings.load();
+    const passkeys = new PasskeyStore(storage.documents, now);
     // Resolved below once the sidecar-backed config store exists; the auth store reads it lazily.
     let oidc = null;
     let operatorConfigPeek = () => null;
     const auth = new AuthStore({
-        stateDir: config.stateDir, env, settings, log, now,
-        passkeysEnabled: () => passkeys.available(),
+        documents: storage.documents, env, settings, log, now,
+        passkeysEnabled: async () => (await passkeys.available()),
         oidcEnabled: () => oidc?.enabledSync() ?? false,
         oidcAvailable: () => oidc?.availableSync() ?? false,
         oidcProbe: () => oidc?.resolve() ?? Promise.resolve(),
         passkeyConfigFlag: () => { const cfg = operatorConfigPeek(); return cfg === null ? null : cfg.webui_passkey_enabled; },
     });
+    await auth.initialize();
     settings.hooks = {
-        hashPassword: (pw) => auth.hashPassword(pw),
+        hashPassword: async (pw) => (await auth.hashPassword(pw)),
         onPasswordChanged: () => { auth.invalidatePasswordHashCache(); },
     };
-    settings.applyStartupWorkspace();
+    await settings.applyStartupWorkspace();
     config.defaultWorkspace = settings.defaultWorkspace;
     const release = loadReleaseInfo({ webRoot: config.webRoot });
     const stampedRelease = loadReleaseInfo({ webRoot: config.webRoot }, { verifyCheckout: false });
     const runningSourceRevision = checkoutRevision(config.webRoot);
     // Container images bake `TALARIA_WEB_VERSION` (Python `api/_version.py`) because .git is not shipped.
     const version = opts.version ?? detectWebuiVersion(release, config.webRoot, (env.TALARIA_WEB_VERSION ?? '').trim() || packageVersion());
-    const updateNotifications = new UpdateNotificationStore(config.stateDir, () => new Date(now() * 1000));
+    const updateNotifications = new UpdateNotificationStore(storage.documents, () => new Date(now() * 1000));
+    await updateNotifications.initialize();
     const verifiedRunningVersion = /^web-(?:exp-)?v\d+\.\d+\.\d+$/.test(version) ? version : null;
-    updateNotifications.reconcileInterruptedUpdates(runningSourceRevision ?? release.sourceRevision, verifiedRunningVersion);
+    await updateNotifications.reconcileInterruptedUpdates(runningSourceRevision ?? release.sourceRevision, verifiedRunningVersion);
     const home = opts.home ?? config.homeDir;
     const PROFILE_RE = /^[a-z0-9][a-z0-9_-]{0,63}$/;
     // Python `init_profile_state` + `switch_profile(process_wide=False)`: the sticky `~/.hermes/active_profile` is
@@ -124,15 +134,39 @@ export function createDeps(opts) {
         if (profile && !isRootProfile(profile))
             return profile.charAt(0).toUpperCase() + profile.slice(1);
         try {
-            return displayBotName(settings.load().bot_name);
+            return displayBotName(settings.peek().bot_name);
         }
         catch {
             return displayBotName(null);
         }
     };
-    // Python `_resolve_profile_home_for_name`: root aliases and invalid names clamp to the base home.
-    // Isolated mode never resolves outside the pinned home, whatever name is asked for (Python `_resolve_profile_home_for_name`).
-    const profileHome = (name) => (isolatedProfile === null && name && !isRootProfile(name) && PROFILE_RE.test(name) ? join(baseHome, 'profiles', name) : isolatedProfile === null ? baseHome : config.hermesHome);
+    // Python `_resolve_profile_home_for_name`: root aliases and invalid names clamp to the base home; a named home resolving
+    // outside the profiles root throws (Python `relative_to`), so no consumer runs it against the root or outside home.
+    // Isolated mode never resolves outside the pinned home, whatever name is asked for.
+    const profileHome = (name) => {
+        if (isolatedProfile !== null)
+            return config.hermesHome;
+        if (!name || isRootProfile(name) || !PROFILE_RE.test(name))
+            return baseHome;
+        const contained = containedProfileHome(baseHome, name);
+        if (contained === null)
+            throw new ProfileError(escapedProfileMessage(name), 400);
+        return contained;
+    };
+    const agentHomes = () => {
+        if (isolatedProfileMode())
+            return [baseHome];
+        let names;
+        try {
+            names = readdirSync(join(baseHome, 'profiles'));
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            names = [];
+        }
+        return [...new Set([baseHome, ...names.filter((name) => PROFILE_RE.test(name)).map(profileHome)])];
+    };
     const attachmentRoot = () => {
         const override = (env.HERMES_WEBUI_ATTACHMENT_DIR ?? '').trim();
         return resolvePathLikePython(override ? override.replace(/^~(?=$|\/)/, home) : join(config.stateDir, 'attachments'));
@@ -141,19 +175,25 @@ export function createDeps(opts) {
     const agentConfig = new AgentConfig({ sidecar: () => sidecar, env });
     /** A profile's config.yaml `model` as [model, provider] as written; '' / null when unset or not yet read. */
     const profileDefaultModel = (profile) => {
-        const cfg = agentConfig.peek(profileHome(profile ?? activeProfile()));
+        let cfg;
+        try {
+            cfg = agentConfig.peek(profileHome(profile ?? activeProfile()));
+        }
+        catch {
+            return ['', null];
+        }
         if (typeof cfg?.model === 'string')
             return [cfg.model.trim(), null];
         const { default: d, provider: p } = asDict(cfg?.model);
         return [typeof d === 'string' ? d.trim() : '', typeof p === 'string' && p ? p : null];
     };
     const events = new SessionEventBus(isRootProfile);
-    const drafts = new DraftStore(config.sessionDir);
-    const registry = new StreamRegistry();
+    const drafts = new DraftStore(storage.documents);
+    const registry = new StreamRegistry((id) => gatewayStreamVisible(id, profileHome(activeProfile())));
     const activeStreamIds = registry.liveIds;
     const runningCronJobs = new Map();
     const workspaces = new WorkspaceRegistry({
-        stateDir: config.stateDir,
+        documents: storage.documents,
         defaultWorkspace: () => config.defaultWorkspace,
         profileHome,
         activeProfile,
@@ -172,34 +212,34 @@ export function createDeps(opts) {
         return Number.isFinite(raw) && raw >= 1 ? raw : 100;
     };
     const store = new SessionStore({
-        sessionDir: config.sessionDir,
+        storage,
         drafts,
         events,
         // Python `_profile_default_model_state`: the profile's own config.yaml model, else the global default. The provider
         // always comes with its model, so a provider-only profile never pairs with another profile's model.
-        defaults: (profile) => {
+        defaults: async (profile) => {
             let [model, provider] = profileDefaultModel(profile);
             if (!model) {
-                const s = settings.load();
+                const s = settings.peek();
                 model = typeof s.default_model === 'string' ? s.default_model : '';
                 provider = model && typeof s.default_model_provider === 'string' && s.default_model_provider ? s.default_model_provider : null;
             }
             const [bare, modelProvider] = parseProviderQualifiedModel(model) ?? [model || null, provider];
-            return { workspace: workspaces.lastWorkspace(profile), model: bare, modelProvider };
+            return { workspace: (await workspaces.lastWorkspace(profile)), model: bare, modelProvider };
         },
         activeStreamIds: () => activeStreamIds,
         now,
         log,
         cacheMax,
-        onDeleted: (sid) => { backgroundStore.evict(sid); },
+        onDeleted: async (sid) => { (await backgroundStore.delete(sid)); },
     });
-    const projects = new ProjectStore(resolve(config.stateDir, 'projects.json'), () => store.readIndexEntries(), isRootProfile);
-    const shares = new ShareStore(resolve(config.stateDir, 'shares'), now);
+    const projects = new ProjectStore(storage.documents, async () => (await store.readIndexEntries()), isRootProfile);
+    const shares = new ShareStore(storage.documents, now);
     const yoloSessions = new Set();
     const attachmentDir = (sid) => join(attachmentRoot(), (sid || 'session').replace(/[^\w.-]/g, '_').slice(0, 120));
-    const cliSessions = new CliSessionSource({ store, profileHome, lastWorkspace: (p) => workspaces.lastWorkspace(p), backgroundProjectId: (kind, p) => projects.ensureSystemProject(kind, p, { create: kind === 'webhook' || projects.hasUserProjects(p) }), now, log });
+    const cliSessions = new CliSessionSource({ store, profileHome, profilesMatch, lastWorkspace: async (p) => (await workspaces.lastWorkspace(p)), backgroundProjectId: async (kind, p) => (await projects.ensureSystemProject(kind, p, { create: kind === 'webhook' || (await projects.hasUserProjects(p)) })), now, log });
     const gatewayWatchers = new GatewayWatcherRegistry({ profileHome, now, log, ...(opts.gatewayPollMs !== undefined ? { pollIntervalMs: opts.gatewayPollMs } : {}) });
-    const journal = new RunJournal(config.sessionDir, env);
+    const journal = storage.journals;
     const contextLengths = new Map();
     const contextInflight = new Map();
     const contextKey = (model, provider, profile) => (model?.trim() ? `${profileHome(profile ?? activeProfile())}\0${provider?.trim() ?? ''}\0${model.trim()}` : null);
@@ -239,52 +279,75 @@ export function createDeps(opts) {
                 profileOps.delete(key);
         };
     };
-    const mediaActiveWorkspace = () => {
+    const mediaActiveWorkspace = async () => {
         if (!workspaces.profileSupportsLocalIo(null))
             return null;
         try {
-            const ws = resolvePathLikePython(workspaces.lastWorkspace(activeProfile()));
+            const ws = resolvePathLikePython((await workspaces.lastWorkspace(activeProfile())));
             return statSync(ws).isDirectory() ? ws : null;
         }
         catch {
             return null;
         }
     };
-    const snapshotDir = () => {
-        const override = (env.HERMES_WEBUI_MEDIA_SNAPSHOT_DIR ?? '').trim();
-        return override ? override.replace(/^~(?=$|\/)/, home) : join(config.stateDir, 'media_snapshots');
-    };
-    const mediaPolicy = { home, hermesHome: config.hermesHome, stateDir: config.stateDir, snapshotDir, activeWorkspace: mediaActiveWorkspace };
+    const legacySnapshotDir = (env.HERMES_WEBUI_MEDIA_SNAPSHOT_DIR ?? '').trim().replace(/^~(?=$|\/)/, home) || undefined;
+    const mediaPolicy = { home, hermesHome: config.hermesHome, stateDir: config.stateDir, legacySnapshotDir, activeWorkspace: mediaActiveWorkspace };
     const mediaAccess = { home: config.homeDir, hermesHome: config.hermesHome, extraRoots: env.MEDIA_ALLOWED_ROOTS ?? '', activeWorkspace: mediaActiveWorkspace, policy: mediaPolicy };
+    // TAL-259: record when this server started stamping deliberate shrinks; older backups go to manual review.
+    try {
+        await recoveryStampingSince(storage.documents);
+    }
+    catch (error) {
+        log(`[webui] WARNING: could not record recovery_stamping_since: ${error.message}`);
+    }
     const sessions = new SessionService({
+        recoveryStampingSince: async () => await recoveryStampingSince(storage.documents),
         sidecar: () => sidecar,
         media: { access: mediaAccess, localIo: (profile) => workspaces.profileSupportsLocalIo(profile) },
         profileActivity,
         profileDeleting: (profile) => profiles.isDeleting(profile),
-        backgroundReceipts: (sid) => background.receipts(sid),
+        backgroundReceipts: async (sid) => (await background.receipts(sid)),
+        backgroundPending: async (sid) => (await completions.pendingDelegations(sid)),
         journal,
-        clearRelayCompletions: (sid, profile) => { relay.clearDeleted(sid, profile); },
+        clearRelayCompletions: async (sid, profile) => { (await relay.clearDeleted(sid, profile)); },
         store,
-        cliSessions: (profile, o) => cliSessions.read(profile, o),
+        cliSessions: async (profile, o) => (await cliSessions.read(profile, o)),
+        cliSessionsSync: async (profile, o) => (await cliSessions.readSync(profile, o)),
         claudeCode: new ClaudeCodeSessionSource(() => claudeCodeProjectsDir(env, home)),
         profileHome,
         // The commit runs detached from the request, so it is registered as profile activity until it settles: profile
         // deletion must not remove the memory files the cached Agent is still writing.
-        commitSessionMemory: (sid) => {
+        commitSessionMemory: async (sid) => {
             if (!sidecar)
                 return;
+            const callerProfile = activeProfile();
+            // Reserve deletion protection before the asynchronous lookup knows which profile owns the session.
+            let release = profileActivity('*');
             let profile = null;
             try {
-                profile = store.get(sid, { metadataOnly: true }).profile ?? null;
+                profile = (await store.get(sid, { metadataOnly: true })).profile ?? null;
             }
             catch {
                 profile = null;
             }
-            const release = profileActivity(profile);
-            void sidecar.call('chat.commit_memory', { profile_home: profileHome(profile ?? activeProfile()), session_id: sid })
+            const targetProfile = profile ?? callerProfile;
+            const releaseOwner = profileActivity(targetProfile);
+            release();
+            release = releaseOwner;
+            void Promise.resolve().then(async () => {
+                await sessions.assertWritable(sid, targetProfile);
+                return sidecar.call('chat.commit_memory', { profile_home: profileHome(targetProfile), session_id: sid });
+            })
                 .catch((error) => { log(`[webui] memory commit for ${sid} failed: ${error.message}`); })
                 .finally(release);
         },
+        // Detached like a memory commit: profile deletion waits for the title job, which reads the profile's config.
+        titleClaimed: (session) => {
+            if (profiles.isDeleting(session.profile ?? null))
+                return;
+            const release = profileActivity(session.profile ?? null);
+            void turns.titleClaimed(session).finally(release);
+        },
         drafts,
         events,
         workspaces,
@@ -297,12 +360,12 @@ export function createDeps(opts) {
         profilesMatch,
         assistantName,
         redactEnabled: () => { try {
-            return settings.load().api_redact_enabled !== false;
+            return settings.peek().api_redact_enabled !== false;
         }
         catch {
             return true;
         } },
-        pinnedSessionsLimit: () => { const v = settings.load().pinned_sessions_limit; return typeof v === 'number' && v >= 1 ? v : 3; },
+        pinnedSessionsLimit: () => { const v = settings.peek().pinned_sessions_limit; return typeof v === 'number' && v >= 1 ? v : 3; },
         // Chat runtime (checkpoint 6) replaces these with live stream and cron state.
         runtime: {
             activeStreamIds,
@@ -321,25 +384,34 @@ export function createDeps(opts) {
             activeRunStream: (sid) => registry.activeRunStreamForSession(sid),
             journalDegraded: (streamId) => registry.degradedJournals.has(streamId),
             pendingSteers: (streamId) => turns.pendingSteers(streamId),
-            evictAgent: (sid, endSession) => { if (sidecar)
+            runStatus: (streamId) => turns.runStatus(streamId),
+            compressionStartedAt: (streamId) => turns.compressionStartedAt(streamId),
+            automaticTurnsHeld: async (sid) => (await turns.automaticTurnsHeld(sid)),
+            sessionNotices: (sid) => turns.sessionNotices(sid),
+            sessionGoal: (sid) => turns.sessionGoal(sid),
+            evictAgent: async (sid, endSession) => { if (sidecar && (!endSession || !(await sessions.readOnlyReason(sid))))
                 sidecar.call('chat.evict_agent', endSession ? { session_id: sid, clear_session: true } : { session_id: sid }).catch(() => undefined); },
             closeTerminal: (sid) => { deps.terminals.close(sid); },
             deleteCliSession: async (profile, sid) => {
                 if (!sidecar)
-                    return false;
-                return (await sidecar.call('state_db.delete_cli_session', { profile_home: profileHome(profile ?? activeProfile()), session_id: sid })).ok;
+                    return { ok: false };
+                const targetProfile = profile ?? activeProfile();
+                await sessions.assertWritable(sid, targetProfile);
+                return await sidecar.call('state_db.delete_cli_session', { profile_home: profileHome(targetProfile), session_id: sid, include_compression_lineage: true });
             },
         },
         attachmentDir,
         hermesHome: config.hermesHome,
         home,
         // Python `_sync_session_title_to_state_db`: with `sync_to_insights` on, the state.db row follows a rename.
-        syncTitle: async (session) => {
-            if (!sidecar || !pyBool(settings.load().sync_to_insights))
+        syncTitle: async (session, manual) => {
+            if (!sidecar || !pyBool(settings.peek().sync_to_insights))
                 return;
             // Awaited by callers: the rename/regenerate response and the title stream's teardown follow the state.db write.
             try {
-                await sidecar.call('state_db.sync_title', { profile_home: profileHome(session.profile ?? activeProfile()), session_id: session.session_id, title: session.title });
+                const targetProfile = session.profile ?? activeProfile();
+                sessions.assertWritable(session, targetProfile);
+                await sidecar.call('state_db.sync_title', { profile_home: profileHome(targetProfile), session_id: session.session_id, title: session.title, manual: manual === true });
             }
             catch (error) {
                 log(`[webui] state.db title sync failed for ${session.session_id}: ${error.message}`);
@@ -383,15 +455,22 @@ export function createDeps(opts) {
     });
     // A working-tree mutation refuses while a run is active anywhere it would change files.
     const git = new GitRunner({ env, activeRunIn: (path) => [...registry.activeRuns.values()].some((run) => Boolean(run.workspace) && pathsOverlap(run.workspace, path)) });
-    const rollback = new RollbackStore({ hermesHome: () => profileHome(activeProfile()), knownWorkspaces: () => workspaces.load(activeProfile()).map((w) => w.path) });
+    const rollback = new RollbackStore({
+        sidecar: () => sidecar, profileHome: () => profileHome(activeProfile()), knownWorkspaces: async () => (await workspaces.load(activeProfile())).map((w) => w.path),
+        // A run whose session cannot be read counts as one in the profile: refusing is the safe answer.
+        activeRunInProfile: (home) => [...registry.activeRuns.values()].some((run) => {
+            const session = store.sessions.get(run.session_id);
+            return !session || profileHome(session.profile ?? activeProfile()) === home;
+        }),
+    });
     const uploads = new UploadInbox(attachmentRoot);
     const channels = new SessionChannels();
     const pending = new PendingPrompts(events, now);
     // TAL-372: one durable record per piece of background work; a change refreshes every client showing the session.
-    const backgroundStore = new BackgroundTaskStore(config.sessionDir, now, (sid) => {
+    const backgroundStore = new BackgroundTaskStore(storage.documents, now, async (sid) => {
         let profile = null;
         try {
-            profile = store.get(sid, { metadataOnly: true, promote: false, cacheOnMiss: false }).profile;
+            profile = (await store.get(sid, { metadataOnly: true, promote: false, cacheOnMiss: false })).profile;
         }
         catch {
             profile = null;
@@ -405,7 +484,8 @@ export function createDeps(opts) {
     let completions;
     const relay = new RelayService({
         registry, pending, store, presence: new PresenceLeases(now), profileHome, profilesMatch, fetch: () => lazyFetch, now, log,
-        stateDir: config.stateDir, env, canonicalProfile: (p) => (isRootProfile(p) ? 'default' : p), addListener: (listener) => events.addListener(listener),
+        agentSessions: (profile) => readImportableAgentSessionRowsAsync(join(profileHome(profile), 'state.db')),
+        documents: storage.documents, env, canonicalProfile: (p) => (isRootProfile(p) ? 'default' : p), addListener: (listener) => events.addListener(listener),
     });
     const turns = new TurnRunner({
         store,
@@ -416,14 +496,17 @@ export function createDeps(opts) {
         profileDeleting: (profile) => profiles.isDeleting(profile),
         updateInProgress: () => deps.updates.blocksNewWork(),
         workspaceBusy: (workspace) => deps.git.workspaceBusy(workspace),
+        checkpointStoreBusy: (profile) => rollback.storeBusy(profileHome(profile ?? activeProfile())),
         syncTitle: (session) => sessions.deps.syncTitle(session),
         // Python `sync_session_usage` after a settled turn: with `sync_to_insights` on, the state.db row carries the usage.
         syncUsage: async (session, model) => {
-            if (!sidecar || !pyBool(settings.load().sync_to_insights))
+            if (!sidecar || !pyBool(settings.peek().sync_to_insights))
                 return;
             try {
+                const targetProfile = session.profile ?? activeProfile();
+                sessions.assertWritable(session, targetProfile);
                 await sidecar.call('state_db.sync_usage', {
-                    profile_home: profileHome(session.profile ?? activeProfile()), session_id: session.session_id,
+                    profile_home: profileHome(targetProfile), session_id: session.session_id,
                     input_tokens: session.input_tokens || 0, output_tokens: session.output_tokens || 0, estimated_cost: typeof session.estimated_cost === 'number' ? session.estimated_cost : null,
                     cache_read_tokens: session.cache_read_tokens || 0, cache_write_tokens: session.cache_write_tokens || 0,
                     model, title: session.title, message_count: session.messages.length,
@@ -433,12 +516,22 @@ export function createDeps(opts) {
                 log(`[webui] state.db usage sync failed for ${session.session_id}: ${error.message}`);
             }
         },
+        configPath: (home) => agentConfig.path(home),
         profileConfig: async (profile) => { try {
             return await agentConfig.read(profileHome(profile ?? activeProfile()));
         }
         catch {
             return null;
         } },
+        personalities: (profile) => agentConfig.agentPersonalities(profileHome(profile ?? activeProfile())),
+        providerLabel: (profile, provider) => catalog.providerLabel(profileHome(profile ?? activeProfile()), provider),
+        titleRefreshEvery: () => { try {
+            const every = Number(settings.peek().auto_title_refresh_every);
+            return Number.isInteger(every) && every > 0 ? every : 0;
+        }
+        catch {
+            return 0;
+        } },
         env,
         hermesHome: config.hermesHome,
         // Python `display_hermes_home`: the home shown to the model, `~`-relative when it sits under $HOME.
@@ -453,7 +546,7 @@ export function createDeps(opts) {
         now,
         log,
         redactEnabled: () => { try {
-            return settings.load().api_redact_enabled !== false;
+            return settings.peek().api_redact_enabled !== false;
         }
         catch {
             return true;
@@ -464,7 +557,7 @@ export function createDeps(opts) {
     });
     // Services read `deps.fetch` lazily so tests can swap the outbound HTTP client after boot.
     const lazyFetch = (input, init) => deps.fetch(input, init);
-    const catalog = new ProviderCatalog({ sidecar: () => sidecar, config: agentConfig, env, now, log, costBudget: () => coerceProviderCostBudgetValue(settings.load().provider_cost_budget), quotaThresholds: (profile) => settings.quotaThresholds(profile), isRootProfileHome: (h) => resolvePathLikePython(h) === resolvePathLikePython(config.hermesHome), stateDir: config.stateDir });
+    const catalog = new ProviderCatalog({ sidecar: () => sidecar, config: agentConfig, env, now, log, costBudget: () => coerceProviderCostBudgetValue(settings.peek().provider_cost_budget), quotaThresholds: async (profile) => (await settings.quotaThresholds(profile)), isRootProfileHome: (h) => resolvePathLikePython(h) === resolvePathLikePython(config.hermesHome), documents: storage.documents });
     const agentStatus = () => {
         const describe = sidecar?.describe ?? null;
         const found = Boolean(describe?.agent_dir);
@@ -478,7 +571,7 @@ export function createDeps(opts) {
         isolatedProfileMode,
         isolatedProfileName,
         config: agentConfig,
-        defaultWorkspace: (profile) => workspaces.profileDefaultWorkspace(profile),
+        defaultWorkspace: async (profile) => (await workspaces.profileDefaultWorkspace(profile)),
         models: (h) => catalog.models(h),
         streamsActive: () => activeStreamIds.size > 0,
         profileRunsActive: (name) => {
@@ -494,23 +587,22 @@ export function createDeps(opts) {
             }
             for (const sessionId of sessionIds) {
                 let profile = null;
-                try {
-                    profile = store.get(sessionId, { metadataOnly: true }).profile ?? null;
-                }
-                catch {
-                    continue;
-                }
+                const session = store.sessions.get(sessionId);
+                if (!session)
+                    return true;
+                profile = session.profile ?? null;
                 if (profiles.isRootProfile(profile ?? 'default') ? profiles.isRootProfile(name) : profile === name)
                     return true;
             }
             for (const [profile, count] of profileOps)
-                if (count > 0 && (profiles.isRootProfile(profile) ? profiles.isRootProfile(name) : profile === name))
+                if (count > 0 && (profile === '*' || (profiles.isRootProfile(profile) ? profiles.isRootProfile(name) : profile === name)))
                     return true;
             return false;
         },
-        tombstoneFile: join(config.stateDir, 'deleted-profiles.json'),
+        documents: storage.documents,
         log,
     }, now);
+    await profiles.initialize();
     rootAlias = (name) => profiles.isRootProfile(name);
     const onboarding = new Onboarding({
         settings,
@@ -521,13 +613,13 @@ export function createDeps(opts) {
         sidecar: () => sidecar,
         agentStatus,
         isAuthEnabled: () => auth.isAuthEnabled(),
-        workspaces: () => ({ items: workspaces.load(activeProfile()), last: workspaces.lastWorkspace(activeProfile()) }),
+        workspaces: async () => ({ items: (await workspaces.load(activeProfile())), last: (await workspaces.lastWorkspace(activeProfile())) }),
         models: (h) => catalog.models(h),
         defaultWorkspace: () => config.defaultWorkspace,
         defaultModel: () => (env.HERMES_WEBUI_DEFAULT_MODEL ?? '').trim(),
         log,
     });
-    oidc = new OidcService({ env, operatorConfig: () => agentConfig.read(config.hermesHome), profileHome, fetch: () => lazyFetch, pinned: () => ({ lookup: deps.dnsLookup, fetch: deps.pinnedFetch }), now, log });
+    oidc = new OidcService({ env, operatorConfig: () => agentConfig.read(baseHome), profileHome, fetch: () => lazyFetch, pinned: () => ({ lookup: deps.dnsLookup, fetch: deps.pinnedFetch }), now, log });
     operatorConfigPeek = () => agentConfig.peek(config.hermesHome);
     settings.hooks.defaultModel = () => profileDefaultModel(null)[0];
     settings.hooks.defaultModelProvider = () => profileDefaultModel(null)[1] ?? undefined;
@@ -571,10 +663,18 @@ export function createDeps(opts) {
             },
         };
     };
-    completions = new CompletionDrain({ sidecar: () => sidecar, baseHome, profileHome: (p) => profileHome(p ?? activeProfile()), activeProfile, store, channels, registry, startTurn: (session, prompt) => {
-            // TAL-542: a wakeup repairs a stale pair from the cached catalog only (Python `prefer_cached_catalog`), never waiting on a build.
-            const [model, modelProvider] = (session.model ? catalog.sessionModelRepair(profileHome(session.profile ?? activeProfile()), session.model, session.model_provider) : null) ?? [session.model, session.model_provider];
-            return turns.start(session, { msg: prompt, attachments: [], workspace: session.workspace, model, modelProvider, source: 'process_wakeup' });
+    completions = new CompletionDrain({ documents: storage.documents, sidecar: () => sidecar, configPath: (home) => agentConfig.path(home), readConfig: (home) => agentConfig.read(home), env, baseHome, profileHome: (p) => profileHome(p ?? activeProfile()), activeProfile, store, channels, registry, isReadOnly: async (session) => (await sessions.isReadOnly(session)), startTurn: async (session, prompt, completionKeys, backgroundUpdate) => {
+            // TAL-577: a wakeup passes the user-turn admission; a stale runtime answers a retryable 409, which defers it on a retry timer.
+            // TAL-542: its model repair reads the cached catalog only (Python `prefer_cached_catalog`), never waiting on a build.
+            try {
+                await ensureAgentRuntimeCurrent(sidecar);
+                return (await turns.startServerTurn(session, { msg: prompt, source: 'process_wakeup', completionKeys, backgroundUpdate }));
+            }
+            catch (error) {
+                if (error instanceof HttpFailure)
+                    return { _status: error.status, error: error.message, retryable: error.extra.retryable === true };
+                throw error;
+            }
         }, background, now, log, ...(opts.completionPollMs !== undefined ? { pollMs: opts.completionPollMs } : {}) });
     const mcpHealth = new McpHealthProber({ fetch: () => lazyFetch, now, log });
     // Dashboard reachability is probed in the background (Python `dashboard_probe.get_dashboard_status`), never per request.
@@ -585,7 +685,7 @@ export function createDeps(opts) {
         if (at - dashboardCheckedAt < 30)
             return;
         dashboardCheckedAt = at;
-        agentConfig.read(profileHome(activeProfile())).then((cfg) => dashboardStatus(cfg, env, lazyFetch)).then((status) => { dashboardRunning = status.running === true; }).catch(() => { dashboardRunning = false; });
+        Promise.resolve().then(() => agentConfig.read(profileHome(activeProfile()))).then((cfg) => dashboardStatus(cfg, env, lazyFetch)).then((status) => { dashboardRunning = status.running === true; }).catch(() => { dashboardRunning = false; });
     };
     const extensionsEnabled = () => { try {
         return deps.extensions.enabledSync();
@@ -593,6 +693,8 @@ export function createDeps(opts) {
     catch {
         return false;
     } };
+    sessions.owner = new GatewaySessions({ service: sessions, sidecar: () => sidecar, registry, journal, events,
+        profileHome, activeProfile, redactEnabled: sessions.deps.redactEnabled, now, log });
     const deps = {
         config,
         settings,
@@ -611,7 +713,7 @@ export function createDeps(opts) {
         requestScope,
         isRootProfile,
         assistantName,
-        onboardingCompleted: () => truthy(env.HERMES_WEBUI_SKIP_ONBOARDING) || Boolean(settings.load().onboarding_completed),
+        onboardingCompleted: () => truthy(env.HERMES_WEBUI_SKIP_ONBOARDING) || Boolean(settings.peek().onboarding_completed),
         health: () => ({ sessions: store.sessions.size, activeStreams: activeStreamIds.size, activeRuns: registry.activeRuns.size, runs: [...registry.activeRuns.values()].map((r) => ({ phase: r.phase, started_at: r.started_at })), lastRunFinishedAt: registry.lastRunFinishedAt }),
         sessions,
         sessionStore: store,
@@ -634,7 +736,7 @@ export function createDeps(opts) {
         git,
         rollback,
         uploads,
-        mediaPolicy,
+        escapeGrants: new EscapeGrants(now),
         mediaAccess,
         worktreeLocks: { lockedByStream: (s) => Boolean(s.active_stream_id && activeStreamIds.has(s.active_stream_id)), lockedByTerminal: (sid, worktreePath) => { const term = deps.terminals.get(sid); return Boolean(term?.isAlive) && resolvePathLikePython(term?.workspace ?? '') === resolvePathLikePython(worktreePath); } },
         sidecar: () => sidecar,
@@ -657,11 +759,11 @@ export function createDeps(opts) {
         oidc,
         passkeys,
         nativeOidcLimiter: new WindowLimiter(60, 10, now),
-        clearPasskeys: () => { passkeys.clear(); },
+        clearPasskeys: async () => { (await passkeys.clear()); },
         skills: new SkillsService({ sidecar: () => sidecar, config: agentConfig, log }),
         mcp: new McpService({ sidecar: () => sidecar, config: agentConfig, health: mcpHealth }),
         completions,
-        hygiene: new HygieneTicker({ env, stateDir: config.stateDir, port: () => config.port, journal, activeJournalPaths: () => turns.activeJournalPaths(), now, log, sweeps: [() => { completions.sweep(); }] }),
+        hygiene: new HygieneTicker({ env, stateDir: config.stateDir, port: () => config.port, journal, now, log, sweeps: [() => { completions.sweep(); }, async () => { (await turns.sweep()); }] }),
         mcpHealth,
         nowSeconds: now,
         // Python `_webui_runtime_payload`: the four owner sections with their `available` flags.
@@ -680,12 +782,14 @@ export function createDeps(opts) {
         requestShutdown: () => { setTimeout(() => { process.kill(process.pid, 'SIGINT'); }, 300).unref(); },
         // Embedded shells are separate process groups that would outlive the worker: terminate and reap them on both exits.
         // A running retention sweep stops before the exit, like on shutdown.
-        requestRestart: () => { void waitUntilRestartSafe(restartBlockers, { log }).then(() => deps.hygiene.stop()).then(() => auth.flushPersistence()).then(() => { deps.terminals.closeAll({ immediate: true }); purgeAgentPycache(); process.exit(RESTART_EXIT_CODE); }); },
+        requestRestart: () => { void waitUntilRestartSafe(restartBlockers, { log }).then(() => deps.gatewayRestarts.quiesce()).then(() => deps.hygiene.stop()).then(() => auth.flushPersistence()).then(() => store.close()).then(() => { deps.terminals.closeAll({ immediate: true }); purgeAgentPycache(); process.exit(RESTART_EXIT_CODE); }); },
         updates: null,
         updateNotifications,
+        gatewayRestarts: null,
         cspLimiter: new WindowLimiter(60, 100, now),
         clientEventLimiter: new WindowLimiter(60, 30, now),
         ttsLimiter: new WindowLimiter(2, 1, now),
+        profileActivity,
         fetch: opts.fetch ?? fetch,
         dnsLookup: systemDnsLookup,
         pinnedFetch,
@@ -698,10 +802,12 @@ export function createDeps(opts) {
             log,
             publishSessionsChanged: (reason, profile) => { events.publish(reason, { profile }); },
             runningJobs: runningCronJobs,
+            updateInProgress: () => deps.updates.blocksNewWork(),
             modelOptionFor: async (home, model, provider) => { await catalog.warmModelOptions(home); return catalog.modelOptionFor(home, model, provider); },
         }),
         kanban: new KanbanService({ sidecar: () => sidecar, config: agentConfig }),
-        extensions: new ExtensionService({ env, stateDir: config.stateDir, isAuthEnabled: () => auth.isAuthEnabled(), fetch: lazyFetch, log }),
+        extensions: new ExtensionService({ documents: storage.documents, env, stateDir: config.stateDir, isAuthEnabled: () => auth.isAuthEnabled(), fetch: lazyFetch, log }),
+        dashboardPlugins: new DashboardPlugins({ env, hermesHome: config.hermesHome, settings }),
         terminals,
         commitMessage: async (session, systemPrompt, userPrompt) => {
             if (!sidecar)
@@ -725,9 +831,12 @@ export function createDeps(opts) {
     };
     const purgeAgentPycache = () => { const dir = sidecar?.describe?.agent_dir; if (dir)
         purgePycache(dir); };
+    let recoveredAgentRevision = null;
+    let pendingRuntimeRecovery = null;
     deps.updates = new UpdateService({
         webRoot: config.webRoot,
         getJson: githubJson(lazyFetch, env),
+        getPublicJson: githubJson(lazyFetch, env, 'https://api.github.com'),
         experimental: ghcrExperimental(lazyFetch),
         stateDir: config.stateDir,
         identity: { release: () => release, stamped: () => stampedRelease, runningSourceRevision: () => runningSourceRevision },
@@ -739,30 +848,124 @@ export function createDeps(opts) {
             return deps.version;
         },
         agentDir: () => sidecar?.describe?.agent_dir ?? null,
-        channel: () => normalizeChannel(settings.load().update_channel),
-        agentChannel: () => normalizeChannel(settings.load().agent_update_channel),
-        includeAgent: () => !pyBool(settings.load().ignore_agent_updates),
-        autoApply: () => settings.load().check_for_updates !== false && settings.load().auto_apply_updates === true,
-        checkEnabled: () => !truthy(env.HERMES_WEBUI_TEST_NETWORK_BLOCK) && settings.load().check_for_updates !== false,
-        autoNotification: {
-            begin: () => updateNotifications.begin({ owner: '*', profile: 'default', serverOwner: true }, 'webui').id,
-            transition: (id, phase, expectedIdentity, verifiedIdentity, detail) => { updateNotifications.transition(id, phase, expectedIdentity, verifiedIdentity, detail); },
+        agentHomes,
+        ...(sidecar?.onHandshake ? { onAgentReconnect: (listener) => sidecar.onHandshake(listener) } : {}),
+        recoverAgent: async (probe = false, signal) => {
+            if (!sidecar)
+                throw new Error('Hermes Agent sidecar is unavailable for recovery.');
+            if (sidecar.status === 'starting' || sidecar.status === 'restarting' || sidecar.status === 'stopped')
+                throw new Error('Agent recovery is waiting for its sidecar connection.');
+            let result = await sidecar.call('runtime.agent_recovery', { probe }, { ...(signal ? { signal } : {}), timeoutMs: 660_000 });
+            if (signal?.aborted)
+                throw new Error('Agent recovery was cancelled.');
+            if (!probe && result.local_restore && result.revision)
+                recoveredAgentRevision = result.revision;
+            if (probe) {
+                if (pendingRuntimeRecovery?.fingerprint === result.fingerprint && restartBlockers().restart_blocked
+                    && (sidecar.describe?.agent_revision !== recoveredAgentRevision || !sidecar.describe?.compatible)) {
+                    return { ...result, waiting_for_idle: true, detail: 'Agent recovery is waiting for active Web work to finish before refreshing its runtime.' };
+                }
+                return result;
+            }
+            if (!result.ok || (result.owed && !result.runtime_pending))
+                return result;
+            if (result.revision)
+                recoveredAgentRevision = result.revision;
+            if (result.runtime_pending)
+                pendingRuntimeRecovery = result;
+            const runtime = await sidecar.call('runtime.status', {}, { ...(signal ? { signal } : {}), timeoutMs: 5000 });
+            if (signal?.aborted)
+                throw new Error('Agent recovery was cancelled.');
+            if (recoveredAgentRevision && (runtime.agent_revision !== recoveredAgentRevision || !runtime.compatible)) {
+                if (restartBlockers().restart_blocked)
+                    return { ...result, waiting_for_idle: true, detail: 'Agent recovery is waiting for active Web work to finish before refreshing its runtime.' };
+                if (['ready', 'incompatible'].includes(sidecar.status))
+                    sidecar.recycle('Verified retained Agent recovery requires the current interpreter and source');
+                throw new Error('Agent services recovered; waiting for the current sidecar runtime to become ready.');
+            }
+            if (result.runtime_pending && recoveredAgentRevision)
+                result = await sidecar.call('runtime.agent_recovery', { complete_revision: recoveredAgentRevision }, { ...(signal ? { signal } : {}), timeoutMs: 660_000 });
+            if (signal?.aborted || !result.ok || result.owed)
+                throw new Error(result.detail || 'Agent recovery remains recorded until loaded readiness is verified.');
+            await sidecar.call('runtime.ensure_current', {}, { ...(signal ? { signal } : {}), timeoutMs: 5000 });
+            if (signal?.aborted)
+                throw new Error('Agent recovery was cancelled.');
+            if (!runtime.compatible || runtime.stale)
+                throw new Error('Agent recovery has no matching loaded runtime evidence; admission remains closed.');
+            catalog.invalidate(undefined, undefined, { preserveConfirmed: true });
+            recoveredAgentRevision = null;
+            pendingRuntimeRecovery = null;
+            return result;
         },
-        blockers: restartBlockers,
-        scheduleRestart: () => { setTimeout(() => { void waitUntilRestartSafe(restartBlockers, { maxWaitMs: Infinity, log }).then(() => { deps.requestRestart(); }); }, 2000).unref(); },
-        gatewayRestart: async () => {
+        recoveryChanged: (state) => updateNotifications.agentRecovery(state),
+        hasPendingRecovery: () => updateNotifications.hasPendingAgentRecovery(),
+        agentMutation: async (path, revision, mutate, consent) => {
             if (!sidecar)
                 throw new Error('Hermes Agent sidecar is unavailable');
-            return sidecar.call('gateway.restart', { profile_home: profileHome(activeProfile()) }, { timeoutMs: 300_000 });
+            const begin = await sidecar.call('runtime.agent_mutation', { action: 'begin', agent_dir: path, revision, homes: agentHomes(), ...(consent?.mutationIntent ? { intent: consent.mutationIntent } : {}), ...(consent?.refreshToken ? { refresh_token: consent.refreshToken } : {}) }, { timeoutMs: 330_000 });
+            if (begin.refresh_confirmation)
+                return { ok: false, refresh_confirmation: begin.refresh_confirmation, message: begin.detail };
+            if (!begin.ok || !begin.token)
+                throw new Error(begin.detail || 'Agent writer quiescence was not verified.');
+            const token = begin.token;
+            const leasedGit = async (args, cwd, timeoutMs = 10_000) => {
+                if (resolve(cwd) !== resolve(path))
+                    throw new Error('Agent writer lease cannot mutate another checkout.');
+                const result = await sidecar.call('runtime.agent_mutation', { action: 'git', agent_dir: path, token, args, timeout_ms: timeoutMs }, { timeoutMs: 330_000 });
+                return { ok: result.ok, out: result.detail };
+            };
+            let result;
+            try {
+                result = await mutate(leasedGit, () => sidecar.call('runtime.agent_mutation', { action: 'sync', agent_dir: path, token }, { timeoutMs: 330_000 }));
+            }
+            catch (error) {
+                try {
+                    await sidecar.call('runtime.agent_mutation', { action: 'finish', agent_dir: path, token }, { timeoutMs: 330_000 });
+                }
+                catch { /* The native pause journal retains any unverified recovery obligation. */ }
+                throw error;
+            }
+            const resumed = await sidecar.call('runtime.agent_mutation', { action: 'finish', agent_dir: path, token }, { timeoutMs: 330_000 });
+            return resumed.ok ? { ...result, ...(result.gateway_restart === 'waiting_for_idle' ? { gateway_restart: 'resumed' } : {}) }
+                : { ...result, ok: false, restart_scheduled: false, message: resumed.detail || 'Agent writer resume remains unverified; its recovery obligation is retained.' };
         },
+        agentSync: async (agentDir) => {
+            if (!sidecar)
+                throw new Error('Hermes Agent sidecar is unavailable');
+            return sidecar.call('runtime.sync_dependencies', { agent_dir: agentDir }, { timeoutMs: 330_000 });
+        },
+        channel: () => normalizeChannel(settings.peek().update_channel),
+        agentChannel: () => normalizeChannel(settings.peek().agent_update_channel),
+        includeAgent: () => !pyBool(settings.peek().ignore_agent_updates),
+        summarizeAutomatically: () => settings.peek().check_for_updates !== false && settings.peek().summarize_updates_automatically !== false,
+        autoApply: () => settings.peek().check_for_updates !== false && settings.peek().auto_apply_updates === true,
+        checkEnabled: () => !truthy(env.HERMES_WEBUI_TEST_NETWORK_BLOCK) && settings.peek().check_for_updates !== false,
+        autoNotification: {
+            begin: async () => (await updateNotifications.begin({ owner: '*', profile: 'default', serverOwner: true }, 'webui')).id,
+            transition: async (id, phase, expectedIdentity, verifiedIdentity, detail) => { (await updateNotifications.transition(id, phase, expectedIdentity, verifiedIdentity, detail)); },
+        },
+        blockers: restartBlockers,
+        scheduleRestart: () => { setTimeout(() => { void waitUntilRestartSafe(restartBlockers, { maxWaitMs: Infinity, log }).then(() => { deps.requestRestart(); }); }, 2000).unref(); },
+        gatewayRestarting: () => deps.gatewayRestarts.restarting(),
         llm: async (system, user) => {
-            if (!sidecar || !pyBool(settings.load().whats_new_summary_enabled))
+            if (!sidecar)
                 return '';
             const result = await sidecar.call('aux.complete', { profile_home: profileHome(activeProfile()), task: 'update_summary', messages: [{ role: 'system', content: system }, { role: 'user', content: user }] });
             return result.text;
         },
         log,
     });
+    deps.gatewayRestarts = new GatewayRestartQueue({
+        notifications: updateNotifications,
+        blockers: (profile) => gatewayRestartBlockers(config.hermesHome, profileHome(profile), now()),
+        updating: () => deps.updates.blocksNewWork(),
+        restart: async (profile) => {
+            if (!sidecar)
+                throw new Error('Hermes Agent sidecar is unavailable');
+            return restartGateway(sidecar, profileHome(profile));
+        },
+        log,
+    });
     return deps;
 }
 /** Python `_read_active_profile_file`: the sticky profile name, or `default` when absent, unreadable, or malformed. */
@@ -775,4 +978,10 @@ function readActiveProfileFile(hermesHome, pattern) {
         return 'default';
     }
 }
+export function createStorage(config, now = () => Date.now() / 1000, profileHome = (name) => name === 'default' ? config.hermesHome : join(config.hermesHome, 'profiles', name)) {
+    if (config.storage !== 'json')
+        throw new Error(`Unknown TALARIA_STORAGE=${JSON.stringify(config.storage)}; supported backends: json`);
+    const storage = new JsonStorage({ directory: config.sessionDir, stateDir: config.stateDir, profileHome, env: config.env, now, stampingSince: async () => (await recoveryStampingSince(storage.documents)) });
+    return storage;
+}
 //# sourceMappingURL=runtime.js.map