yepanywhere 0.5.2 → 0.6.1

package/dist/app.js

@@ -1,15 +1,18 @@
 import { RESPONSE_ALREADY_SENT } from "@hono/node-server/utils/response";
+import { DEFAULT_PROJECT_QUEUE_QUIET_SECONDS, DEFAULT_PROMPT_CACHE_KEEPALIVE_INACTIVITY_MINUTES, buildEffectiveAgentContext, clampProjectQueueQuietSeconds, } from "../bundled/@yep-anywhere/shared/dist/index.js";
 import { Hono } from "hono";
+import { compress } from "hono/compress";
 import { join } from "node:path";
 import { createAuthRoutes } from "./auth/routes.js";
 import { updateAllowedHosts } from "./middleware/allowed-hosts.js";
 import { createAuthMiddleware } from "./middleware/auth.js";
+import { getAllowedFilePaths, shouldIncludeProjects, updateFileAccess, } from "./middleware/file-access.js";
 import { corsMiddleware, hostCheckMiddleware, requireCustomHeader, } from "./middleware/security.js";
 import { CODEX_SESSIONS_DIR, CodexSessionScanner, } from "./projects/codex-scanner.js";
 import { GEMINI_TMP_DIR, GeminiSessionScanner, } from "./projects/gemini-scanner.js";
-import { GROK_SESSIONS_DIR } from "./projects/paths.js";
+import { GROK_SESSIONS_DIR, PI_SESSIONS_DIR } from "./projects/paths.js";
 import { ProjectScanner } from "./projects/scanner.js";
-import { PushNotifier } from "./push/index.js";
+import { InactivityPushNotifier, PushNotifier, } from "./push/index.js";
 import { createPushRoutes } from "./push/routes.js";
 import { createRemoteAccessRoutes } from "./remote-access/index.js";
 import { createActivityRoutes } from "./routes/activity.js";
@@ -27,16 +30,20 @@ import { createInboxRoutes } from "./routes/inbox.js";
 import { createNetworkBindingRoutes } from "./routes/network-binding.js";
 import { createOnboardingRoutes } from "./routes/onboarding.js";
 import { createProcessesRoutes } from "./routes/processes.js";
+import { createGlobalProjectQueueRoutes, createProjectQueueRoutes, } from "./routes/project-queue.js";
 import { createProjectsRoutes } from "./routes/projects.js";
 import { createProvidersRoutes } from "./routes/providers.js";
 import { createCodexUpdateRoutes } from "./routes/codex-updates.js";
 import { createPublicSharePublicRoutes, createPublicShareRoutes, } from "./routes/public-shares.js";
 import { createRecentsRoutes } from "./routes/recents.js";
-import { createServerAdminRoutes } from "./routes/server-admin.js";
+import { createServerAdminRoutes, triggerServerRestart, } from "./routes/server-admin.js";
+import { createEnvSettingsRoutes } from "./routes/env-settings.js";
 import { createServerInfoRoutes } from "./routes/server-info.js";
+import { createSessionIndexRoutes } from "./routes/session-index.js";
 import { createSessionsRoutes } from "./routes/sessions.js";
 import { createSettingsRoutes } from "./routes/settings.js";
 import { createSharingRoutes } from "./routes/sharing.js";
+import { createSupervisorQueueRoutes } from "./routes/supervisor-queue.js";
 import { ClaudeOllamaProvider } from "./sdk/providers/claude-ollama.js";
 import { grokACPProvider } from "./sdk/providers/grok-acp.js";
 import { createLocalFileRoutes } from "./routes/local-file.js";
@@ -44,14 +51,21 @@ import { createLocalImageRoutes } from "./routes/local-image.js";
 import { createUploadRoutes } from "./routes/upload.js";
 import { createSpeechRoutes } from "./routes/speech.js";
 import { createVersionRoutes } from "./routes/version.js";
+import { createWorkstreamRoutes } from "./routes/workstreams.js";
 import { WS_INTERNAL_AUTHENTICATED } from "./middleware/internal-auth.js";
-import { configureProviderRuntime } from "./sdk/providers/index.js";
+import { configureProviderRuntime, getProvider, } from "./sdk/providers/index.js";
+import { AttachmentStagingService } from "./uploads/AttachmentStagingService.js";
 import { CodexUpdateChecker } from "./services/CodexUpdateChecker.js";
+import { ProjectQueueScheduler } from "./services/ProjectQueueScheduler.js";
+import { SafeRestartService } from "./services/SafeRestartService.js";
 import { CodexSessionReader } from "./sessions/codex-reader.js";
+import { createCodexSessionDiscoveryIndex } from "./sessions/codex-discovery.js";
 import { GeminiSessionReader } from "./sessions/gemini-reader.js";
 import { GrokSessionReader } from "./sessions/grok-reader.js";
 import { OpenCodeSessionReader } from "./sessions/opencode-reader.js";
+import { PiSessionReader } from "./sessions/pi-reader.js";
 import { findSessionSummaryAcrossProviders } from "./sessions/provider-resolution.js";
+import { applyRecapOverlayToSummary } from "./sessions/recap-overlays.js";
 import { normalizeSession } from "./sessions/normalization.js";
 import { ClaudeSessionReader } from "./sessions/reader.js";
 import { ExternalSessionTracker } from "./supervisor/ExternalSessionTracker.js";
@@ -76,9 +90,47 @@ function hasPendingToolCall(messages) {
     }
     return pendingToolUseIds.size > 0;
 }
+function isRecoveredPatientQueueItem(item) {
+    return item.kind === "patient" && item.status === "paused-after-restart";
+}
+function getPreservedRestartWork(sessionQueuePersistenceService) {
+    if (!sessionQueuePersistenceService)
+        return [];
+    const recoveredPatientCount = sessionQueuePersistenceService
+        .list()
+        .filter(isRecoveredPatientQueueItem).length;
+    return recoveredPatientCount > 0
+        ? [
+            {
+                type: "recovered-session-queue",
+                count: recoveredPatientCount,
+            },
+        ]
+        : [];
+}
 export function createApp(options) {
     configureProviderRuntime({ codexCliPath: options.codexCliPath });
     const app = new Hono();
+    const attachmentStagingService = options.attachmentStagingService ??
+        new AttachmentStagingService({
+            dataDir: options.dataDir,
+            maxUploadSizeBytes: options.maxUploadSizeBytes,
+        });
+    options.projectQueueService?.setAttachmentStagingService(attachmentStagingService);
+    // Compress API responses (gzip/deflate). Large session payloads — multi-MB
+    // Codex transcripts — otherwise cross slow first-mile links uncompressed:
+    // Cloudflare-tunnel and Tailscale/LAN clients have nothing compressing the
+    // origin→edge hop (Cloudflare only compresses edge→browser, and cloudflared
+    // ships the origin response raw). Browsers send Accept-Encoding and decompress
+    // transparently, so no client changes are needed; the relay path compresses
+    // separately. The middleware safely skips WebSocket upgrades, SSE
+    // (text/event-stream), already-encoded responses, and sub-1KB bodies. It is a
+    // no-op for internal app.fetch() calls (relayed requests) which send no
+    // Accept-Encoding, but public-share links opened directly in a browser DO send
+    // it — and /public-api/shares/sessions/* serves the same multi-MB session JSON
+    // — so that prefix is covered too. Registered first so it wraps the response.
+    app.use("/api/*", compress());
+    app.use("/public-api/*", compress());
     // Security middleware: host validation, CORS, custom header requirement
     app.use("/api/*", hostCheckMiddleware);
     app.use("/api/*", corsMiddleware);
@@ -114,7 +166,19 @@ export function createApp(options) {
         }));
     }
     // Create dependencies
-    const codexScanner = new CodexSessionScanner();
+    const codexDiscoveryIndexes = new Map();
+    const getCodexDiscoveryIndex = (sessionsDir) => {
+        const existing = codexDiscoveryIndexes.get(sessionsDir);
+        if (existing)
+            return existing;
+        const created = createCodexSessionDiscoveryIndex(options.dataDir, sessionsDir);
+        if (created) {
+            codexDiscoveryIndexes.set(sessionsDir, created);
+        }
+        return created;
+    };
+    const codexDiscoveryIndex = getCodexDiscoveryIndex(CODEX_SESSIONS_DIR);
+    const codexScanner = new CodexSessionScanner(codexDiscoveryIndex ? { discoveryIndex: codexDiscoveryIndex } : {});
     const geminiScanner = new GeminiSessionScanner();
     const projectScanCachePath = options.dataDir
         ? join(options.dataDir, "indexes", "project-scanner-cache.json")
@@ -125,11 +189,27 @@ export function createApp(options) {
         geminiScanner,
         projectScanCachePath,
         projectMetadataService: options.projectMetadataService,
+        workstreamService: options.workstreamService,
         eventBus: options.eventBus,
         cacheTtlMs: options.projectScanCacheTtlMs,
     });
     const readerCache = new Map();
     const maxReaderCacheSize = 500;
+    const closeReader = async (key, reader) => {
+        if (!reader.close)
+            return;
+        try {
+            await reader.close();
+        }
+        catch (error) {
+            console.warn(`[App] Failed to close session reader ${key}:`, error);
+        }
+    };
+    const disposeSessionReaders = async () => {
+        const entries = Array.from(readerCache.entries());
+        readerCache.clear();
+        await Promise.all(entries.map(([key, reader]) => closeReader(key, reader)));
+    };
     const getOrCreateReader = (key, factory) => {
         const cached = readerCache.get(key);
         if (cached)
@@ -140,7 +220,10 @@ export function createApp(options) {
             const oldestKey = readerCache.keys().next().value;
             if (!oldestKey)
                 break;
+            const oldestReader = readerCache.get(oldestKey);
             readerCache.delete(oldestKey);
+            if (oldestReader)
+                void closeReader(oldestKey, oldestReader);
         }
         return reader;
     };
@@ -155,10 +238,15 @@ export function createApp(options) {
         switch (project.provider) {
             case "codex":
             case "codex-oss":
-                return getOrCreateReader(`codex::${project.sessionDir}::${project.path}`, () => new CodexSessionReader({
-                    sessionsDir: project.sessionDir,
-                    projectPath: project.path,
-                }));
+                return getOrCreateReader(`codex::${project.sessionDir}::${project.path}`, () => {
+                    const discoveryIndex = getCodexDiscoveryIndex(project.sessionDir);
+                    return new CodexSessionReader({
+                        sessionsDir: project.sessionDir,
+                        projectPath: project.path,
+                        summaryParserWorkerMode: options.codexSummaryParserWorkerMode,
+                        ...(discoveryIndex ? { discoveryIndex } : {}),
+                    });
+                });
             case "gemini":
             case "gemini-acp":
                 return getOrCreateReader(`gemini::${GEMINI_TMP_DIR}::${project.path}`, () => new GeminiSessionReader({
@@ -172,6 +260,7 @@ export function createApp(options) {
                 return getOrCreateReader(`claude::${project.sessionDir}${mergedKey}`, () => new ClaudeSessionReader({
                     sessionDir: project.sessionDir,
                     additionalDirs: project.mergedSessionDirs,
+                    summaryParserWorkerMode: options.claudeSummaryParserWorkerMode,
                     getContextWindow: mis
                         ? (model, provider) => mis.getContextWindow(model, provider)
                         : undefined,
@@ -186,12 +275,22 @@ export function createApp(options) {
                     sessionsDir: GROK_SESSIONS_DIR,
                     projectPath: project.path,
                 }));
+            case "pi":
+                return getOrCreateReader(`pi::${PI_SESSIONS_DIR}::${project.path}`, () => new PiSessionReader({
+                    sessionsDir: PI_SESSIONS_DIR,
+                    projectPath: project.path,
+                }));
         }
     };
-    const codexReaderFactory = (projectPath) => getOrCreateReader(`codex-extra::${CODEX_SESSIONS_DIR}::${projectPath}`, () => new CodexSessionReader({
-        sessionsDir: CODEX_SESSIONS_DIR,
-        projectPath,
-    }));
+    const codexReaderFactory = (projectPath) => getOrCreateReader(`codex-extra::${CODEX_SESSIONS_DIR}::${projectPath}`, () => {
+        const discoveryIndex = getCodexDiscoveryIndex(CODEX_SESSIONS_DIR);
+        return new CodexSessionReader({
+            sessionsDir: CODEX_SESSIONS_DIR,
+            projectPath,
+            summaryParserWorkerMode: options.codexSummaryParserWorkerMode,
+            ...(discoveryIndex ? { discoveryIndex } : {}),
+        });
+    });
     const geminiReaderFactory = (projectPath) => getOrCreateReader(`gemini-extra::${GEMINI_TMP_DIR}::${projectPath}`, () => new GeminiSessionReader({
         sessionsDir: GEMINI_TMP_DIR,
         projectPath,
@@ -201,7 +300,11 @@ export function createApp(options) {
         sessionsDir: GROK_SESSIONS_DIR,
         projectPath,
     }));
-    const getSessionSummary = async (sessionId, projectId) => {
+    const piReaderFactory = (projectPath) => getOrCreateReader(`pi-extra::${PI_SESSIONS_DIR}::${projectPath}`, () => new PiSessionReader({
+        sessionsDir: PI_SESSIONS_DIR,
+        projectPath,
+    }));
+    const getSessionSummary = async (sessionId, projectId, summaryOptions) => {
         const project = await scanner.getProject(projectId);
         if (!project)
             return null;
@@ -209,13 +312,20 @@ export function createApp(options) {
             readerFactory,
             codexSessionsDir: CODEX_SESSIONS_DIR,
             codexReaderFactory,
+            codexSummaryParserWorkerMode: options.codexSummaryParserWorkerMode,
             geminiSessionsDir: GEMINI_TMP_DIR,
             geminiReaderFactory,
             geminiHashToCwd: geminiScanner.getHashToCwd(),
             grokSessionsDir: GROK_SESSIONS_DIR,
             grokReaderFactory,
-        }, options.sessionMetadataService?.getProvider(sessionId));
-        return resolved?.summary ?? null;
+            piSessionsDir: PI_SESSIONS_DIR,
+            piReaderFactory,
+            claudeSummaryParserWorkerMode: options.claudeSummaryParserWorkerMode,
+        }, options.sessionMetadataService?.getProvider(sessionId), summaryOptions);
+        const summary = resolved?.summary ?? null;
+        if (!summary)
+            return null;
+        return applyRecapOverlayToSummary(summary, options.sessionMetadataService?.getRecapMessages(sessionId) ?? []);
     };
     let supervisor;
     const getHeartbeatTurnCandidates = async () => {
@@ -233,18 +343,22 @@ export function createApp(options) {
             readerFactory,
             codexSessionsDir: CODEX_SESSIONS_DIR,
             codexReaderFactory,
+            codexSummaryParserWorkerMode: options.codexSummaryParserWorkerMode,
             geminiSessionsDir: GEMINI_TMP_DIR,
             geminiReaderFactory,
             geminiHashToCwd: geminiScanner.getHashToCwd(),
             grokSessionsDir: GROK_SESSIONS_DIR,
             grokReaderFactory,
+            piSessionsDir: PI_SESSIONS_DIR,
+            piReaderFactory,
+            claudeSummaryParserWorkerMode: options.claudeSummaryParserWorkerMode,
         };
         for (const [sessionId, metadata] of heartbeatSessionIds) {
             if (supervisor.getProcessForSession(sessionId)) {
                 continue;
             }
             for (const project of projects) {
-                const resolved = await findSessionSummaryAcrossProviders(project, sessionId, project.id, providerResolutionDeps, metadata.provider);
+                const resolved = await findSessionSummaryAcrossProviders(project, sessionId, project.id, providerResolutionDeps, metadata.provider, { readMode: "head" });
                 if (!resolved) {
                     continue;
                 }
@@ -277,14 +391,21 @@ export function createApp(options) {
         idleTimeoutMs: options.idleTimeoutMs,
         defaultPermissionMode: options.defaultPermissionMode,
         eventBus: options.eventBus,
+        sessionMetadataService: options.sessionMetadataService,
         maxWorkers: options.maxWorkers,
         idlePreemptThresholdMs: options.idlePreemptThresholdMs,
         maxQueueSize: options.maxQueueSize,
+        sessionQueuePersistenceService: options.sessionQueuePersistenceService,
         // Save executor for remote sessions to support resume
         onSessionExecutor: options.sessionMetadataService
             ? (sessionId, executor) => options.sessionMetadataService?.setExecutor(sessionId, executor) ??
                 Promise.resolve()
             : undefined,
+        // Durably record a model's real context window the moment a process
+        // observes it (in the result message), independent of any client fetch.
+        onContextWindowObserved: options.modelInfoService
+            ? (model, contextWindow, provider) => options.modelInfoService?.recordContextWindow(model, contextWindow, provider)
+            : undefined,
         onSessionSummary: getSessionSummary,
         getHeartbeatTurnSettings: options.serverSettingsService || options.sessionMetadataService
             ? (sessionId) => {
@@ -304,6 +425,25 @@ export function createApp(options) {
         getHeartbeatTurnCandidates: options.sessionMetadataService
             ? getHeartbeatTurnCandidates
             : undefined,
+        getPromptCacheKeepaliveSettings: (providerName) => {
+            const capability = getProvider(providerName)?.promptCacheKeepalive;
+            if (!capability?.supportsNoContextPollutionNudge) {
+                return {
+                    enabled: false,
+                    inactivityMinutes: DEFAULT_PROMPT_CACHE_KEEPALIVE_INACTIVITY_MINUTES,
+                };
+            }
+            const saved = options.serverSettingsService?.getSetting("promptCacheKeepalive")?.providers?.[providerName];
+            const mode = saved?.mode ?? capability.defaultMode;
+            const inactivityMinutes = saved?.inactivityMinutes ??
+                capability.defaultInactivityMinutes ??
+                DEFAULT_PROMPT_CACHE_KEEPALIVE_INACTIVITY_MINUTES;
+            return {
+                enabled: mode === "auto",
+                inactivityMinutes,
+            };
+        },
+        getCacheMissBillingSettings: () => options.serverSettingsService?.getSetting("cacheMissBilling"),
     });
     // Create external session tracker if eventBus is available
     const externalTracker = options.eventBus
@@ -317,6 +457,85 @@ export function createApp(options) {
             getSessionSummary,
         })
         : undefined;
+    let projectQueueScheduler;
+    if (options.eventBus && options.projectQueueService) {
+        projectQueueScheduler = new ProjectQueueScheduler({
+            eventBus: options.eventBus,
+            projectQueueService: options.projectQueueService,
+            supervisor,
+            attachmentStagingService,
+            sessionQueuePersistenceService: options.sessionQueuePersistenceService,
+            externalTracker,
+            getIdleGraceMs: () => (clampProjectQueueQuietSeconds(options.serverSettingsService?.getSetting("projectQueueQuietSeconds")) ?? DEFAULT_PROJECT_QUEUE_QUIET_SECONDS) * 1000,
+            getGlobalInstructions: () => buildEffectiveAgentContext({
+                globalInstructions: options.serverSettingsService?.getSetting("globalInstructions"),
+                hints: options.serverSettingsService?.getSetting("agentContextHints"),
+            }),
+            onSessionStarted: async ({ item, process }) => {
+                if (item.target.type !== "new-session")
+                    return;
+                const metadata = options.sessionMetadataService;
+                if (!metadata)
+                    return;
+                const provider = item.target.provider ?? process.provider;
+                if (provider) {
+                    await metadata.setProvider(process.sessionId, provider);
+                }
+                if (item.target.executor) {
+                    await metadata.setExecutor(process.sessionId, item.target.executor);
+                }
+                if (item.message.text.trim()) {
+                    await metadata.setInitialPrompt(process.sessionId, item.message.text);
+                }
+                if (item.target.model) {
+                    await metadata.setRequestedModel(process.sessionId, item.target.model);
+                }
+                await metadata.updateMetadata(process.sessionId, {
+                    ...(process.promptSuggestionMode !== undefined
+                        ? { promptSuggestionMode: process.promptSuggestionMode }
+                        : {}),
+                    ...(process.recapAfterSeconds !== undefined
+                        ? { recapAfterSeconds: process.recapAfterSeconds }
+                        : {}),
+                });
+            },
+        });
+    }
+    const isManualReloadMode = process.env.NO_BACKEND_RELOAD === "true" ||
+        process.env.NO_FRONTEND_RELOAD === "true";
+    const safeRestartService = options.eventBus && isManualReloadMode
+        ? new SafeRestartService({
+            eventBus: options.eventBus,
+            getWorkerActivity: () => supervisor.getWorkerActivity(),
+            getPreservedWork: () => getPreservedRestartWork(options.sessionQueuePersistenceService),
+            preparePreservedWork: async () => {
+                await supervisor.preserveRestartablePatientQueuesForRestart();
+            },
+            restart: () => triggerServerRestart({
+                notificationService: options.notificationService,
+                beforeRestart: disposeSessionReaders,
+            }),
+            pauseProjectQueueDispatch: async () => {
+                const service = options.projectQueueService;
+                if (!service || service.listAll().length === 0)
+                    return false;
+                if (service.isDispatchPaused())
+                    return false;
+                await service.pauseDispatch("restart");
+                return true;
+            },
+            resumeProjectQueueDispatch: async () => {
+                const service = options.projectQueueService;
+                if (!service)
+                    return;
+                const dispatchState = service.getDispatchState();
+                if (dispatchState.status === "paused" &&
+                    dispatchState.reason === "restart") {
+                    await service.resumeDispatch();
+                }
+            },
+        })
+        : undefined;
     // Create PushNotifier if push notifications are enabled
     // This sends push notifications when sessions need user input
     if (options.eventBus && options.pushService) {
@@ -327,6 +546,16 @@ export function createApp(options) {
             connectedBrowsers: options.connectedBrowsers,
         });
     }
+    if (options.eventBus && options.pushService && options.projectQueueService) {
+        new InactivityPushNotifier({
+            eventBus: options.eventBus,
+            pushService: options.pushService,
+            supervisor,
+            projectQueueService: options.projectQueueService,
+            externalTracker,
+            connectedBrowsers: options.connectedBrowsers,
+        });
+    }
     if (options.eventBus && options.serverSettingsService) {
         new LifecycleWebhookService({
             eventBus: options.eventBus,
@@ -358,7 +587,9 @@ export function createApp(options) {
         installId: options.installId,
         voiceInputEnabled: options.voiceInputEnabled,
         getEnabledVoiceBackends: () => options.speechBackendRegistry?.enabledIds() ?? [],
+        getVoiceBackendStatuses: () => options.speechBackendRegistry?.allInfo() ?? [],
         getVoiceBackendCapabilities: () => options.speechBackendRegistry?.enabledCapabilities() ?? {},
+        getClientDefaults: () => options.serverSettingsService?.getSetting("clientDefaults"),
     }));
     // Server info (host/port binding info for Local Access settings)
     if (options.serverHost && options.serverPort) {
@@ -369,11 +600,23 @@ export function createApp(options) {
             deviceBridgeAvailable: !!options.deviceBridgeService?.hasBinary(),
         }));
     }
+    // Documented startup env vars (read-only; secrets redacted server-side).
+    // The HOST entry is annotated with the live listen addresses; read the holder
+    // lazily since its getter is set after startServer() binds.
+    app.route("/api/env-settings", createEnvSettingsRoutes({
+        getActiveListeners: () => options.networkBindingCallbackHolder?.getActiveListeners?.() ?? [],
+    }));
     // Server admin routes (restart, always available for remote relay)
     app.route("/api/server", createServerAdminRoutes({
         supervisor,
         notificationService: options.notificationService,
+        beforeRestart: disposeSessionReaders,
     }));
+    if (options.sessionIndexService) {
+        app.route("/api/session-index", createSessionIndexRoutes({
+            sessionIndexService: options.sessionIndexService,
+        }));
+    }
     // Network binding routes (runtime port/interface configuration)
     if (options.networkBindingService &&
         options.networkBindingCallbackHolder &&
@@ -414,6 +657,7 @@ export function createApp(options) {
         notificationService: options.notificationService,
         sessionMetadataService: options.sessionMetadataService,
         projectMetadataService: options.projectMetadataService,
+        projectQueueService: options.projectQueueService,
         sessionIndexService: options.sessionIndexService,
         codexScanner,
         codexSessionsDir: CODEX_SESSIONS_DIR,
@@ -423,14 +667,53 @@ export function createApp(options) {
         geminiReaderFactory,
         grokSessionsDir: GROK_SESSIONS_DIR,
         grokReaderFactory,
+        piSessionsDir: PI_SESSIONS_DIR,
+        piReaderFactory,
         sessionAutoArchiveDays: options.sessionAutoArchiveDays,
     }));
+    if (options.projectQueueService) {
+        app.route("/api/project-queue", createGlobalProjectQueueRoutes({
+            scanner,
+            readerFactory,
+            projectQueueService: options.projectQueueService,
+            projectQueueScheduler,
+            sessionIndexService: options.sessionIndexService,
+            codexSessionsDir: CODEX_SESSIONS_DIR,
+            codexReaderFactory,
+            geminiSessionsDir: GEMINI_TMP_DIR,
+            geminiReaderFactory,
+            grokSessionsDir: GROK_SESSIONS_DIR,
+            grokReaderFactory,
+            piSessionsDir: PI_SESSIONS_DIR,
+            piReaderFactory,
+            sessionMetadataService: options.sessionMetadataService,
+            sessionQueuePersistenceService: options.sessionQueuePersistenceService,
+        }));
+        app.route("/api/projects", createProjectQueueRoutes({
+            scanner,
+            readerFactory,
+            projectQueueService: options.projectQueueService,
+            projectQueueScheduler,
+            sessionIndexService: options.sessionIndexService,
+            codexSessionsDir: CODEX_SESSIONS_DIR,
+            codexReaderFactory,
+            geminiSessionsDir: GEMINI_TMP_DIR,
+            geminiReaderFactory,
+            grokSessionsDir: GROK_SESSIONS_DIR,
+            grokReaderFactory,
+            piSessionsDir: PI_SESSIONS_DIR,
+            piReaderFactory,
+            sessionMetadataService: options.sessionMetadataService,
+        }));
+    }
+    app.route("/api", createSupervisorQueueRoutes(supervisor));
     app.route("/api", createSessionsRoutes({
         supervisor,
         scanner,
         readerFactory,
         externalTracker,
         notificationService: options.notificationService,
+        sessionIndexService: options.sessionIndexService,
         sessionMetadataService: options.sessionMetadataService,
         eventBus: options.eventBus,
         codexScanner,
@@ -441,8 +724,12 @@ export function createApp(options) {
         geminiReaderFactory,
         grokSessionsDir: GROK_SESSIONS_DIR,
         grokReaderFactory,
+        piSessionsDir: PI_SESSIONS_DIR,
+        piReaderFactory,
         serverSettingsService: options.serverSettingsService,
+        workstreamService: options.workstreamService,
         modelInfoService: options.modelInfoService,
+        sessionQueuePersistenceService: options.sessionQueuePersistenceService,
         dataDir: options.dataDir,
     }));
     app.route("/api/processes", createProcessesRoutes({
@@ -478,6 +765,7 @@ export function createApp(options) {
             }
         },
         sessionIndexService: options.sessionIndexService,
+        sessionMetadataService: options.sessionMetadataService,
     }));
     // Inbox routes (cross-project session aggregation)
     app.route("/api/inbox", createInboxRoutes({
@@ -487,6 +775,7 @@ export function createApp(options) {
         notificationService: options.notificationService,
         sessionIndexService: options.sessionIndexService,
         sessionMetadataService: options.sessionMetadataService,
+        projectQueueService: options.projectQueueService,
         codexScanner,
         codexSessionsDir: CODEX_SESSIONS_DIR,
         codexReaderFactory,
@@ -495,6 +784,8 @@ export function createApp(options) {
         geminiReaderFactory,
         grokSessionsDir: GROK_SESSIONS_DIR,
         grokReaderFactory,
+        piSessionsDir: PI_SESSIONS_DIR,
+        piReaderFactory,
         sessionAutoArchiveDays: options.sessionAutoArchiveDays,
     }));
     // Global sessions route (flat list of all sessions for navigation)
@@ -514,13 +805,27 @@ export function createApp(options) {
         geminiReaderFactory,
         grokSessionsDir: GROK_SESSIONS_DIR,
         grokReaderFactory,
+        piSessionsDir: PI_SESSIONS_DIR,
+        piReaderFactory,
         eventBus: options.eventBus,
         sessionAutoArchiveDays: options.sessionAutoArchiveDays,
     }));
-    // Files routes (file browser)
-    app.route("/api/projects", createFilesRoutes({ scanner }));
+    // Files routes (file browser). Absolute/`~` paths go through the shared
+    // file-access allow-set (same as the media doors below).
+    app.route("/api/projects", createFilesRoutes({
+        scanner,
+        allowedPaths: getAllowedFilePaths,
+        includeProjects: shouldIncludeProjects,
+    }));
     // Git status routes
     app.route("/api/projects", createGitStatusRoutes({ scanner }));
+    if (options.serverSettingsService && options.workstreamService) {
+        app.route("/api/projects", createWorkstreamRoutes({
+            scanner,
+            serverSettingsService: options.serverSettingsService,
+            workstreamService: options.workstreamService,
+        }));
+    }
     // Recents routes (recently visited sessions)
     if (options.recentsService) {
         app.route("/api/recents", createRecentsRoutes({
@@ -536,6 +841,8 @@ export function createApp(options) {
             geminiReaderFactory,
             grokSessionsDir: GROK_SESSIONS_DIR,
             grokReaderFactory,
+            piSessionsDir: PI_SESSIONS_DIR,
+            piReaderFactory,
         }));
     }
     // Provider routes (multi-provider detection)
@@ -547,7 +854,9 @@ export function createApp(options) {
     if (options.serverSettingsService) {
         app.route("/api/settings", createSettingsRoutes({
             serverSettingsService: options.serverSettingsService,
+            sessionMetadataService: options.sessionMetadataService,
             onAllowedHostsChanged: updateAllowedHosts,
+            onFileAccessChanged: updateFileAccess,
             onRemoteSessionPersistenceChanged: options.remoteSessionService
                 ? (enabled) => options.remoteSessionService?.setDiskPersistenceEnabled(enabled)
                 : undefined,
@@ -699,6 +1008,7 @@ export function createApp(options) {
             scanner,
             upgradeWebSocket: options.upgradeWebSocket,
             maxUploadSizeBytes: options.maxUploadSizeBytes,
+            attachmentStagingService,
         }));
     }
     // Speech audio WebSocket route
@@ -708,19 +1018,23 @@ export function createApp(options) {
             upgradeWebSocket: options.upgradeWebSocket,
             dataDir: options.dataDir,
             serverSettingsService: options.serverSettingsService,
+            xaiSttApiKey: options.xaiSttApiKey,
+            shareXaiSttApiKeyWithClients: options.shareXaiSttApiKeyWithClients,
         }));
     }
-    // Local image serving (opt-in, restricted to allowed paths)
-    if (options.allowedImagePaths && options.allowedImagePaths.length > 0) {
-        app.route("/api/local-image", createLocalImageRoutes({
-            allowedPaths: options.allowedImagePaths,
-            scanner,
-        }));
-        app.route("/api/local-file", createLocalFileRoutes({
-            allowedPaths: options.allowedImagePaths,
-            scanner,
-        }));
-    }
+    // Local media/file serving — both doors enforce the live file-access
+    // allow-set (uploads ∪ temp ∪ home ∪ custom, plus projects). Always mounted;
+    // the policy denies anything outside the set.
+    app.route("/api/local-image", createLocalImageRoutes({
+        allowedPaths: getAllowedFilePaths,
+        includeProjects: shouldIncludeProjects,
+        scanner,
+    }));
+    app.route("/api/local-file", createLocalFileRoutes({
+        allowedPaths: getAllowedFilePaths,
+        includeProjects: shouldIncludeProjects,
+        scanner,
+    }));
     // Push notification routes
     if (options.pushService) {
         app.route("/api/push", createPushRoutes({ pushService: options.pushService }));
@@ -733,11 +1047,12 @@ export function createApp(options) {
             browserProfileService: options.browserProfileService,
         }));
         // Dev routes (manual reload workflow) - mounted when manual reload is enabled
-        const isDevMode = process.env.NO_BACKEND_RELOAD === "true" ||
-            process.env.NO_FRONTEND_RELOAD === "true";
-        if (isDevMode) {
+        if (isManualReloadMode) {
             console.log("[Dev] Mounting dev routes at /api/dev");
-            app.route("/api/dev", createDevRoutes({ eventBus: options.eventBus }));
+            app.route("/api/dev", createDevRoutes({
+                eventBus: options.eventBus,
+                safeRestartService,
+            }));
         }
     }
     // Debug streaming routes (always mounted in dev, useful for debugging markdown rendering)
@@ -754,7 +1069,7 @@ export function createApp(options) {
             return RESPONSE_ALREADY_SENT;
         });
     }
-    return { app, supervisor, scanner, readerFactory };
+    return { app, supervisor, scanner, readerFactory, disposeSessionReaders };
 }
 // Default app for backwards compatibility (health check only)
 // Full API requires createApp() with SDK injection