@bytetrue/byspace 0.11.3 → 0.12.0

package/node_modules/@getpaseo/server/dist/server/server/bootstrap.js

@@ -120,6 +120,8 @@ import { archiveByScope, archivePersistedWorkspaceRecord, killTerminalsForWorksp
 import { setupAutoArchiveOnMerge } from "./auto-archive-on-merge/index.js";
 import { wrapSessionMessage } from "./messages.js";
 import { createConfiguredTerminalManager } from "../terminal/terminal-manager-factory.js";
+import { createPersistingTerminalManager, restorePersistedTerminals, } from "../terminal/terminal-persistence.js";
+import { TerminalSessionStore } from "../terminal/terminal-session-store.js";
 import { applyTerminalAgentHookSetting } from "../terminal/agent-hooks/terminal-agent-hook-setting.js";
 import { loadOrCreateDaemonKeyPair } from "./daemon-keypair.js";
 import { createRelayRuntime } from "./relay-runtime.js";
@@ -278,6 +280,17 @@ function mountWebUi(app, config, logger) {
 function resolveExpressTrustProxySetting(config) {
     return config.trustedProxies ?? ["loopback"];
 }
+function applyOptionalConfigLists(initialConfig, config) {
+    if (config.terminalProfiles !== undefined) {
+        initialConfig.terminalProfiles = config.terminalProfiles;
+    }
+    if (config.terminalDefaultShell !== undefined) {
+        initialConfig.terminalDefaultShell = config.terminalDefaultShell;
+    }
+    if (config.agentProfiles !== undefined) {
+        initialConfig.agentProfiles = config.agentProfiles;
+    }
+}
 function createInitialMutableDaemonConfig(config, defaultAppBaseUrl) {
     const providers = config.providerOverrides ?? {};
     const initialConfig = {
@@ -307,12 +320,7 @@ function createInitialMutableDaemonConfig(config, defaultAppBaseUrl) {
         plugins: config.plugins ?? {},
         skills: { selection: config.skillSelection },
     };
-    if (config.terminalProfiles !== undefined) {
-        initialConfig.terminalProfiles = config.terminalProfiles;
-    }
-    if (config.agentProfiles !== undefined) {
-        initialConfig.agentProfiles = config.agentProfiles;
-    }
+    applyOptionalConfigLists(initialConfig, config);
     return initialConfig;
 }
 export async function createPaseoDaemon(config, rootLogger, dependencies = {}) {
@@ -386,8 +394,14 @@ export async function createPaseoDaemon(config, rootLogger, dependencies = {}) {
     });
     let boundListenTarget = null;
     let workspaceRegistry = null;
-    const terminalManager = createConfiguredTerminalManager({
-        getTerminalActivityUrl: () => createTerminalActivityUrl(boundListenTarget),
+    const terminalSessionStore = new TerminalSessionStore(path.join(config.paseoHome, "terminals", "terminals.json"));
+    const terminalManager = createPersistingTerminalManager({
+        inner: createConfiguredTerminalManager({
+            getTerminalActivityUrl: () => createTerminalActivityUrl(boundListenTarget),
+            getDefaultShell: () => daemonConfigStore.get().terminalDefaultShell,
+        }),
+        store: terminalSessionStore,
+        logger,
     });
     applyTerminalAgentHookSetting({ store: daemonConfigStore, logger });
     const serviceProxyPublicBaseUrl = config.serviceProxy?.publicBaseUrl
@@ -642,6 +656,15 @@ export async function createPaseoDaemon(config, rootLogger, dependencies = {}) {
     });
     await workspaceLabelService.initialize();
     logger.info({ elapsed: elapsed() }, "Workspace registries bootstrapped");
+    await restorePersistedTerminals({
+        manager: terminalManager,
+        store: terminalSessionStore,
+        isWorkspaceActive: async (workspaceId) => {
+            const record = await workspaceRegistry.get(workspaceId);
+            return record !== null && record.archivedAt === null;
+        },
+        logger,
+    });
     const teardownArchivedWorkspaceRuntime = (workspaceId) => {
         scriptRuntimeStore.removeForWorkspace(workspaceId);
         releaseWorkspaceServicePortPlan(workspaceId);

package/node_modules/@getpaseo/server/dist/server/server/config.js

@@ -355,6 +355,9 @@ function resolveStaticLoadConfigSettings(env, cli, persisted, hostedAppBaseUrl)
         autoArchiveAfterMerge: persisted.daemon?.autoArchiveAfterMerge ?? false,
         appendSystemPrompt: resolveAppendSystemPrompt(persisted),
         ...resolveProfileLists(persisted),
+        // null in the persisted file means "auto"; the daemon config omits it so
+        // MutableDaemonConfig keeps the absent = auto semantics.
+        terminalDefaultShell: persisted.daemon?.terminalDefaultShell ?? undefined,
         hostnames: mergeHostnames([
             persisted.daemon?.hostnames,
             parseHostnamesEnv(env.PASEO_HOSTNAMES ?? env.PASEO_ALLOWED_HOSTS),
@@ -373,7 +376,7 @@ export function resolveConfigFromPersisted(paseoHome, persisted, options) {
     const cli = resolvedOptions.cli;
     const relayEnabledFallback = resolvedOptions.relayEnabledFallback ?? persisted.daemon?.relay?.enabled === undefined;
     const listen = resolveListenAddress(env, cli, persisted);
-    const { mcpEnabled, mcpInjectIntoAgents, browserToolsEnabled, autoArchiveAfterMerge, appendSystemPrompt, terminalProfiles, agentProfiles, hostnames, trustedProxies, appBaseUrl, } = resolveStaticLoadConfigSettings(env, cli, persisted, hostedAppBaseUrl);
+    const { mcpEnabled, mcpInjectIntoAgents, browserToolsEnabled, autoArchiveAfterMerge, appendSystemPrompt, terminalProfiles, terminalDefaultShell, agentProfiles, hostnames, trustedProxies, appBaseUrl, } = resolveStaticLoadConfigSettings(env, cli, persisted, hostedAppBaseUrl);
     const relay = resolveRelayConfig({
         env,
         persisted,
@@ -411,6 +414,7 @@ export function resolveConfigFromPersisted(paseoHome, persisted, options) {
             : {}),
         appendSystemPrompt,
         terminalProfiles,
+        terminalDefaultShell,
         agentProfiles,
         skillSelection: persisted.agents?.skills?.selection,
         pluginsEnabled: persisted.pluginsEnabled ?? false,

package/node_modules/@getpaseo/server/dist/server/server/daemon-config-store.js

@@ -179,6 +179,9 @@ function pickSupportedPatchFields(patch) {
             ? { appendSystemPrompt: patch.appendSystemPrompt }
             : {}),
         ...(patch.terminalProfiles !== undefined ? { terminalProfiles: patch.terminalProfiles } : {}),
+        ...(patch.terminalDefaultShell !== undefined
+            ? { terminalDefaultShell: patch.terminalDefaultShell }
+            : {}),
         ...(patch.agentProfiles !== undefined ? { agentProfiles: patch.agentProfiles } : {}),
         ...(patch.pluginsEnabled !== undefined ? { pluginsEnabled: patch.pluginsEnabled } : {}),
         ...(patch.plugins !== undefined ? { plugins: patch.plugins } : {}),
@@ -498,6 +501,11 @@ function mergeMutableDaemonPatch(persistedDaemon, patch, persistRelayEnabled) {
         next.appendSystemPrompt = patch.appendSystemPrompt;
     if (patch.terminalProfiles !== undefined)
         next.terminalProfiles = patch.terminalProfiles;
+    // null clears the configured shell (client "Auto" selection); the field stays
+    // in the persisted JSON as null so a later non-null patch replaces it.
+    if (patch.terminalDefaultShell !== undefined) {
+        next.terminalDefaultShell = patch.terminalDefaultShell;
+    }
     if (patch.agentProfiles !== undefined)
         next.agentProfiles = patch.agentProfiles;
     return Object.keys(next).length > 0 ? next : undefined;

package/node_modules/@getpaseo/server/dist/server/server/persisted-config.d.ts

@@ -42,6 +42,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             args: z.ZodOptional<z.ZodArray<z.ZodString>>;
             icon: z.ZodOptional<z.ZodString>;
         }, z.core.$loose>>>;
+        terminalDefaultShell: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         agentProfiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
             id: z.ZodString;
             name: z.ZodString;
@@ -101,6 +102,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             args?: string[] | undefined;
             icon?: string | undefined;
         }[] | undefined;
+        terminalDefaultShell?: string | null | undefined;
         agentProfiles?: {
             [x: string]: unknown;
             id: string;
@@ -162,6 +164,7 @@ export declare const PersistedConfigSchema: z.ZodObject<{
             args?: string[] | undefined;
             icon?: string | undefined;
         }[] | undefined;
+        terminalDefaultShell?: string | null | undefined;
         agentProfiles?: {
             [x: string]: unknown;
             id: string;

package/node_modules/@getpaseo/server/dist/server/server/persisted-config.js

@@ -222,6 +222,9 @@ export const PersistedConfigSchema = z
         terminalAgentHooks: TerminalAgentHookSettingsSchema.optional(),
         appendSystemPrompt: z.string().optional(),
         terminalProfiles: z.array(TerminalProfileSchema).optional(),
+        // null is a valid persisted value meaning "auto"; config.ts omits it
+        // when resolving so MutableDaemonConfig keeps absent = auto.
+        terminalDefaultShell: z.string().min(1).nullish(),
         agentProfiles: z.array(AgentProfileSchema).optional(),
         cors: z
             .object({

package/node_modules/@getpaseo/server/dist/server/server/session.js

@@ -437,6 +437,7 @@ export class Session {
             listTerminalWorkspaceRefs: () => this.listActiveWorkspaceRefs(),
             clientSupportsWrapReflow: () => this.clientCapabilities.has(CLIENT_CAPS.terminalReflowableSnapshot),
             getClientBufferedAmount: () => this.getTransportBufferedAmount(),
+            getConfiguredDefaultShell: () => daemonConfigStore.get().terminalDefaultShell,
         });
         this.agentUpdates = createAgentUpdatesService({
             emit: (message) => this.emit(message),

package/node_modules/@getpaseo/server/dist/server/server/websocket-server.js

@@ -1184,6 +1184,10 @@ export class VoiceAssistantWebSocketServer {
                 projectSetupSkill: true,
                 // COMPAT(terminalAgentHookProviders): added in v0.7.1, remove gate after 2027-09-01.
                 terminalAgentHookProviders: true,
+                // COMPAT(terminalShellConfig): added in v0.7.x, remove gate after 2027-09-01.
+                // Gates terminal.shell.detect plus the terminalDefaultShell config field;
+                // clients without the gate never send either.
+                terminalShellConfig: true,
                 // COMPAT(terminalRestoreModes): added in v0.1.81, remove gate after 2026-11-23.
                 "terminal-restore-modes": true,
                 // COMPAT(terminalInputModeReplay): added in v0.2.6, remove gate after 2027-02-02.

package/node_modules/@getpaseo/server/dist/server/terminal/shell-detect.d.ts

@@ -0,0 +1,51 @@
+export interface DetectedShell {
+    path: string;
+    name: string;
+}
+export interface ShellCandidate {
+    location: string;
+    source: "env" | "dscl" | "etc-shells" | "well-known";
+}
+export interface DetectShellsOptions {
+    platform?: NodeJS.Platform;
+    env?: NodeJS.ProcessEnv;
+    homeDir?: string;
+    /** Overrides candidate discovery; tests inject fixtures here. */
+    candidates?: readonly ShellCandidate[];
+    /** Overrides /etc/shells reading; tests inject fixture text here. */
+    readEtcShells?: () => string | null;
+    /** Overrides the macOS login-shell lookup; tests inject fixture text here. */
+    readMacUserShell?: () => string | null;
+    /** Resolves bare names against PATH. Defaults to PATH walk. */
+    resolveOnPath?: (name: string) => string | null;
+    exists?: (path: string) => boolean;
+}
+/**
+ * Executable suffixes to probe, derived from PATHEXT. The bare name is always
+ * the final fallback for names that already carry an extension.
+ */
+export declare function resolvePathExtSuffixes(env: NodeJS.ProcessEnv): readonly string[];
+/**
+ * Parses `/etc/shells` text into candidate paths. Comments and blank lines are
+ * skipped; entries must be absolute.
+ */
+export declare function parseEtcShells(text: string): string[];
+/**
+ * Parses `dscl . -read /Users/<user> UserShell` output ("UserShell: /bin/zsh").
+ * Returns null when the line is missing or malformed.
+ */
+export declare function parseDsclUserShell(text: string): string | null;
+/**
+ * Runs `dscl . -read /Users/<user> UserShell` and parses the login shell path.
+ * Returns null when dscl is unavailable, fails, or the output is unusable —
+ * detection degrades to the remaining sources rather than failing.
+ */
+export declare function readMacUserShell(homeDir: string): Promise<string | null>;
+/**
+ * Shells installed on this machine, deduped by absolute path, in discovery
+ * order: environment shell first (the strongest signal of what the user
+ * actually uses), then the macOS login shell, then /etc/shells, then
+ * well-known locations. Only paths that exist are returned.
+ */
+export declare function detectInstalledShells(options?: DetectShellsOptions): Promise<DetectedShell[]>;
+//# sourceMappingURL=shell-detect.d.ts.map

package/node_modules/@getpaseo/server/dist/server/terminal/shell-detect.js

@@ -0,0 +1,196 @@
+import { existsSync, readFileSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { basename, delimiter, isAbsolute, join, posix, win32 } from "node:path";
+const WELL_KNOWN_UNIX_SHELLS = [
+    { location: "/bin/bash", source: "well-known" },
+    { location: "/bin/zsh", source: "well-known" },
+    { location: "/usr/bin/bash", source: "well-known" },
+    { location: "/usr/bin/zsh", source: "well-known" },
+    { location: "/usr/local/bin/bash", source: "well-known" },
+    { location: "/usr/local/bin/zsh", source: "well-known" },
+    { location: "/usr/local/bin/fish", source: "well-known" },
+    { location: "/opt/homebrew/bin/bash", source: "well-known" },
+    { location: "/opt/homebrew/bin/zsh", source: "well-known" },
+    { location: "/opt/homebrew/bin/fish", source: "well-known" },
+    { location: "/opt/homebrew/bin/nu", source: "well-known" },
+    { location: "/usr/local/bin/nu", source: "well-known" },
+];
+const WELL_KNOWN_WINDOWS_SHELLS = [
+    { location: "pwsh.exe", source: "well-known" },
+    { location: "powershell.exe", source: "well-known" },
+    { location: "cmd.exe", source: "well-known" },
+];
+/**
+ * Resolves a bare executable name against PATH. On Windows, executables live
+ * under PATHEXT suffixes (.exe and friends), so each PATH entry is probed with
+ * each suffix before the bare name.
+ */
+function resolveOnPathVariable(name, env, suffixes) {
+    const path = env.PATH ?? "";
+    for (const dir of path.split(delimiter)) {
+        if (!dir)
+            continue;
+        for (const suffix of suffixes) {
+            const candidate = join(dir, `${name}${suffix}`);
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Executable suffixes to probe, derived from PATHEXT. The bare name is always
+ * the final fallback for names that already carry an extension.
+ */
+export function resolvePathExtSuffixes(env) {
+    const pathExt = env.PATHEXT ?? ".COM;.EXE;.BAT;.CMD";
+    const suffixes = pathExt
+        .split(";")
+        .map((suffix) => suffix.trim())
+        .filter((suffix) => suffix.length > 0);
+    return [...suffixes, ""];
+}
+function defaultResolveOnPath(env, platform) {
+    const suffixes = platform === "win32" ? resolvePathExtSuffixes(env) : [""];
+    return (name) => resolveOnPathVariable(name, env, suffixes);
+}
+/**
+ * Parses `/etc/shells` text into candidate paths. Comments and blank lines are
+ * skipped; entries must be absolute.
+ */
+export function parseEtcShells(text) {
+    return text
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0 && !line.startsWith("#") && isAbsolute(line));
+}
+/**
+ * Parses `dscl . -read /Users/<user> UserShell` output ("UserShell: /bin/zsh").
+ * Returns null when the line is missing or malformed.
+ */
+export function parseDsclUserShell(text) {
+    const line = text
+        .split("\n")
+        .map((value) => value.trim())
+        .find((value) => value.startsWith("UserShell:"));
+    if (!line) {
+        return null;
+    }
+    const value = line.slice("UserShell:".length).trim();
+    return isAbsolute(value) ? value : null;
+}
+/**
+ * Runs `dscl . -read /Users/<user> UserShell` and parses the login shell path.
+ * Returns null when dscl is unavailable, fails, or the output is unusable —
+ * detection degrades to the remaining sources rather than failing.
+ */
+export async function readMacUserShell(homeDir) {
+    const user = basename(homeDir);
+    try {
+        const stdout = await new Promise((resolve, reject) => {
+            // Domain-joined macOS hosts can make dscl hang on directory-service
+            // lookups; the timeout degrades to the remaining detection sources.
+            execFile("dscl", [".", "-read", `/Users/${user}`, "UserShell"], { timeout: 2000 }, (error, result) => {
+                if (error)
+                    reject(error);
+                else
+                    resolve(result);
+            });
+        });
+        return parseDsclUserShell(stdout);
+    }
+    catch {
+        return null;
+    }
+}
+function toDetectedShell(path, platform) {
+    // basename follows the running host; the name must follow the detected
+    // platform so backslash paths name correctly in tests run on POSIX hosts.
+    const base = platform === "win32" ? win32.basename(path) : posix.basename(path);
+    return { path, name: base };
+}
+/**
+ * Resolves and dedupes candidate shell paths into detected shells. Bare names
+ * resolve against PATH; duplicates and non-existent paths are dropped.
+ * Absoluteness follows the detected platform so Windows paths classify
+ * correctly even when detection runs on a POSIX host.
+ */
+async function resolveDetectedShells(candidates, platform, resolveOnPath, exists) {
+    const isCandidateAbsolute = (location) => platform === "win32" ? win32.isAbsolute(location) : posix.isAbsolute(location);
+    const seen = new Set();
+    const shells = [];
+    for (const candidate of candidates) {
+        const path = isCandidateAbsolute(candidate.location)
+            ? candidate.location
+            : resolveOnPath(candidate.location);
+        if (!path || seen.has(path) || !exists(path)) {
+            continue;
+        }
+        seen.add(path);
+        shells.push(toDetectedShell(path, platform));
+    }
+    return shells;
+}
+async function gatherUnixCandidates(options, platform, env, homeDir) {
+    const candidates = [];
+    const envShell = env.SHELL;
+    if (envShell && isAbsolute(envShell)) {
+        candidates.push({ location: envShell, source: "env" });
+    }
+    if (platform === "darwin") {
+        const userShell = options.readMacUserShell
+            ? options.readMacUserShell()
+            : await readMacUserShell(homeDir);
+        if (userShell) {
+            candidates.push({ location: userShell, source: "dscl" });
+        }
+    }
+    const etcShells = options.readEtcShells ? options.readEtcShells() : readEtcShellsFile();
+    if (etcShells) {
+        for (const entry of parseEtcShells(etcShells)) {
+            candidates.push({ location: entry, source: "etc-shells" });
+        }
+    }
+    candidates.push(...WELL_KNOWN_UNIX_SHELLS);
+    return candidates;
+}
+async function gatherCandidates(options, platform, env, homeDir) {
+    if (options.candidates) {
+        return [...options.candidates];
+    }
+    if (platform === "win32") {
+        // ComSpec mirrors the Unix $SHELL env candidate: the shell the host
+        // itself considers the default, ahead of the well-known probes.
+        const comspec = env.ComSpec || env.COMSPEC;
+        return [
+            ...(comspec ? [{ location: comspec, source: "env" }] : []),
+            ...WELL_KNOWN_WINDOWS_SHELLS,
+        ];
+    }
+    return gatherUnixCandidates(options, platform, env, homeDir);
+}
+/**
+ * Shells installed on this machine, deduped by absolute path, in discovery
+ * order: environment shell first (the strongest signal of what the user
+ * actually uses), then the macOS login shell, then /etc/shells, then
+ * well-known locations. Only paths that exist are returned.
+ */
+export async function detectInstalledShells(options = {}) {
+    const platform = options.platform ?? process.platform;
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? env.HOME ?? "";
+    const exists = options.exists ?? existsSync;
+    const resolveOnPath = options.resolveOnPath ?? defaultResolveOnPath(env, platform);
+    const candidates = await gatherCandidates(options, platform, env, homeDir);
+    return resolveDetectedShells(candidates, platform, resolveOnPath, exists);
+}
+function readEtcShellsFile() {
+    try {
+        return readFileSync("/etc/shells", "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+//# sourceMappingURL=shell-detect.js.map

package/node_modules/@getpaseo/server/dist/server/terminal/terminal-manager-factory.d.ts

@@ -1,6 +1,8 @@
 import type { TerminalManager } from "./terminal-manager.js";
 export interface ConfiguredTerminalManagerOptions {
     getTerminalActivityUrl?: () => string | null;
+    /** Reads daemon.terminalDefaultShell; nullish means auto. */
+    getDefaultShell?: () => string | null | undefined;
 }
 export declare function createConfiguredTerminalManager(options?: ConfiguredTerminalManagerOptions): TerminalManager;
 //# sourceMappingURL=terminal-manager-factory.d.ts.map

package/node_modules/@getpaseo/server/dist/server/terminal/terminal-manager.d.ts

@@ -40,6 +40,7 @@ export interface TerminalManager {
         name?: string;
         title?: string;
         env?: Record<string, string>;
+        shell?: string;
         command?: string;
         args?: string[];
         rows?: number;

package/node_modules/@getpaseo/server/dist/server/terminal/terminal-manager.js

@@ -215,6 +215,7 @@ export function createTerminalManager(managerOptions = {}) {
                     workspaceId: options.workspaceId,
                     name: options.name ?? defaultName,
                     ...(options.title ? { title: options.title } : {}),
+                    ...(options.shell && !options.command ? { shell: options.shell } : {}),
                     ...(options.command ? { command: options.command } : {}),
                     ...(options.args ? { args: options.args } : {}),
                     ...(options.rows !== undefined ? { rows: options.rows } : {}),

package/node_modules/@getpaseo/server/dist/server/terminal/terminal-persistence.d.ts

@@ -0,0 +1,15 @@
+import type { Logger } from "pino";
+import type { TerminalManager } from "./terminal-manager.js";
+import type { TerminalSessionStore } from "./terminal-session-store.js";
+export declare function createPersistingTerminalManager(input: {
+    inner: TerminalManager;
+    store: TerminalSessionStore;
+    logger: Logger;
+}): TerminalManager;
+export declare function restorePersistedTerminals(input: {
+    manager: TerminalManager;
+    store: TerminalSessionStore;
+    isWorkspaceActive: (workspaceId: string) => Promise<boolean>;
+    logger: Logger;
+}): Promise<void>;
+//# sourceMappingURL=terminal-persistence.d.ts.map

package/node_modules/@getpaseo/server/dist/server/terminal/terminal-persistence.js

@@ -0,0 +1,127 @@
+import { promises as fs } from "node:fs";
+// Daemon restarts — crash recovery, auto-update, manual restart, a machine
+// sleep that took the daemon down — otherwise lose every terminal tab, because
+// sessions live only in the terminal worker process. This wrapper mirrors
+// membership changes (create / exit / kill) into a TerminalSessionStore so the
+// daemon can recreate the tabs at startup. Processes and scrollback are not
+// preserved: restored terminals are fresh shells that reuse the original id,
+// so client-side layout references keep resolving.
+export function createPersistingTerminalManager(input) {
+    const { inner, store, logger } = input;
+    const recordsById = new Map();
+    let lastWrittenJson = "";
+    let frozen = false;
+    function scheduleWrite() {
+        const records = Array.from(recordsById.values());
+        const json = JSON.stringify(records);
+        if (json === lastWrittenJson) {
+            return;
+        }
+        lastWrittenJson = json;
+        store.replace(records).catch((error) => {
+            logger.warn({ err: error }, "Failed to persist terminal session metadata");
+        });
+    }
+    const unsubscribe = inner.subscribeTerminalsChanged((event) => {
+        if (frozen) {
+            return;
+        }
+        // The event carries the authoritative post-mutation list for one cwd
+        // bucket. Creations are recorded by the wrapped createTerminal; here we
+        // only mirror removals (shell exit, killTerminal, workspace teardown).
+        const liveIds = new Set(event.terminals.map((terminal) => terminal.id));
+        let changed = false;
+        for (const record of recordsById.values()) {
+            if (record.cwd === event.cwd && !liveIds.has(record.id)) {
+                recordsById.delete(record.id);
+                changed = true;
+            }
+        }
+        if (changed) {
+            scheduleWrite();
+        }
+    });
+    void unsubscribe;
+    return {
+        ...inner,
+        async createTerminal(options) {
+            const session = await inner.createTerminal(options);
+            if (frozen) {
+                return session;
+            }
+            // A short-lived command can exit before createTerminal resolves; its exit
+            // was mirrored (or dropped) before this record existed. Recording it now
+            // would resurrect a dead terminal on the next boot.
+            if (!inner.getTerminal(session.id)) {
+                return session;
+            }
+            const record = {
+                id: session.id,
+                cwd: session.cwd,
+                workspaceId: session.workspaceId,
+                name: session.name,
+                ...(options.command ? { command: options.command } : {}),
+                ...(options.args ? { args: options.args } : {}),
+            };
+            recordsById.set(record.id, record);
+            scheduleWrite();
+            return session;
+        },
+        killAll() {
+            // killAll is shutdown-only (bootstrap stop / worker teardown). Terminals
+            // killed here must survive in the store so the next daemon boot restores
+            // their tabs, so the mirror is frozen permanently instead of tracking
+            // these removals. The daemon process does not use the manager afterwards.
+            frozen = true;
+            inner.killAll();
+        },
+    };
+}
+export async function restorePersistedTerminals(input) {
+    const { manager, store, isWorkspaceActive, logger } = input;
+    let records;
+    try {
+        records = await store.load();
+    }
+    catch (error) {
+        logger.warn({ err: error }, "Skipping terminal tab restore: store unreadable");
+        return;
+    }
+    if (records.length === 0) {
+        return;
+    }
+    const survivors = [];
+    for (const record of records) {
+        try {
+            if (!(await isWorkspaceActive(record.workspaceId))) {
+                logger.info({ terminalId: record.id, workspaceId: record.workspaceId }, "Dropping persisted terminal: workspace gone");
+                continue;
+            }
+            const stat = await fs.stat(record.cwd);
+            if (!stat.isDirectory()) {
+                logger.info({ terminalId: record.id, cwd: record.cwd }, "Dropping persisted terminal: cwd missing");
+                continue;
+            }
+            await manager.createTerminal({
+                id: record.id,
+                cwd: record.cwd,
+                workspaceId: record.workspaceId,
+                name: record.name,
+                ...(record.command ? { command: record.command } : {}),
+                ...(record.args ? { args: record.args } : {}),
+            });
+            survivors.push(record);
+        }
+        catch (error) {
+            logger.warn({ err: error, terminalId: record.id, cwd: record.cwd }, "Failed to restore persisted terminal");
+        }
+    }
+    try {
+        await store.replace(survivors);
+    }
+    catch (error) {
+        logger.warn({ err: error }, "Failed to rewrite terminal session store after restore");
+    }
+    logger.info({ restored: survivors.length, dropped: records.length - survivors.length }, "Terminal tabs restored");
+}
+//# sourceMappingURL=terminal-persistence.js.map

package/node_modules/@getpaseo/server/dist/server/terminal/terminal-session-controller.d.ts

@@ -13,6 +13,8 @@ export interface TerminalSessionControllerOptions {
     listTerminalWorkspaceRoots?: () => Promise<readonly string[]>;
     clientSupportsWrapReflow?: () => boolean;
     getClientBufferedAmount?: () => number | null;
+    /** Reads daemon.terminalDefaultShell; nullish means auto. */
+    getConfiguredDefaultShell?: () => string | null | undefined;
 }
 interface TerminalWorkspaceRef {
     workspaceId: string;
@@ -33,6 +35,7 @@ export declare class TerminalSessionController {
     private readonly listTerminalWorkspaceRoots;
     private readonly clientSupportsWrapReflow;
     private readonly getClientBufferedAmount;
+    private readonly getConfiguredDefaultShell;
     private readonly terminalSizeOwner;
     private readonly subscribedDirectories;
     private unsubscribeTerminalsChanged;
@@ -74,6 +77,7 @@ export declare class TerminalSessionController {
     private handleCreateTerminalRequest;
     private resolveLegacyTerminalWorkspaceId;
     private handleRenameTerminalRequest;
+    private handleShellDetectRequest;
     private handleSubscribeTerminalRequest;
     private handleUnsubscribeTerminalRequest;
     private handleTerminalInput;