labgate 0.5.39 → 0.5.42

package/dist/lib/container.js

@@ -39,6 +39,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeMountFingerprint = computeMountFingerprint;
 exports.prepareMcpServers = prepareMcpServers;
 exports.imageToSifName = imageToSifName;
+exports.isUsableApptainerSif = isUsableApptainerSif;
+exports.ensureSifImage = ensureSifImage;
+exports.resolveSlurmProxyPathToHost = resolveSlurmProxyPathToHost;
 exports.buildCodexOauthPublishSpec = buildCodexOauthPublishSpec;
 exports.buildEntrypoint = buildEntrypoint;
 exports.setupBrowserHook = setupBrowserHook;
@@ -56,10 +59,12 @@ const net_1 = require("net");
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const config_js_1 = require("./config.js");
 const runtime_js_1 = require("./runtime.js");
+const image_pull_lock_js_1 = require("./image-pull-lock.js");
 const audit_js_1 = require("./audit.js");
 const slurm_db_js_1 = require("./slurm-db.js");
 const slurm_poller_js_1 = require("./slurm-poller.js");
 const slurm_cli_passthrough_js_1 = require("./slurm-cli-passthrough.js");
+const startup_stage_lock_js_1 = require("./startup-stage-lock.js");
 const log = __importStar(require("./log.js"));
 /**
  * Compute a deterministic fingerprint of mount-affecting config fields.
@@ -205,6 +210,8 @@ function cleanupLabgateInstructionFile(workdir, filename, deleteWhenEmpty) {
 function buildLabgateInstructionBlock(session) {
     const agentLower = session.agent.toLowerCase();
     const hasMcp = agentLower === 'claude' || agentLower === 'codex';
+    const datasetsPluginEnabled = session.config.plugins?.datasets !== false;
+    const slurmPluginEnabled = session.config.plugins?.slurm !== false;
     const lines = [
         LABGATE_INSTRUCTION_START,
         '## LabGate Sandbox Context (Auto-Managed)',
@@ -237,41 +244,20 @@ function buildLabgateInstructionBlock(session) {
     }
     if (hasMcp) {
         lines.push('');
-        lines.push('### Dataset Management');
-        lines.push('- Use the `labgate-datasets` MCP tools to manage and explore datasets.');
-        lines.push('- Available tools: `list_datasets`, `inspect_dataset`, `search_dataset`, `get_dataset_summary`, `read_dataset_file`, `validate_dataset`, `register_dataset`, `update_dataset`, `unregister_dataset`');
-        lines.push('- Use `register_dataset` to add new host directories as named datasets.');
-        lines.push('');
-        lines.push('### Results Registry');
-        lines.push('- Use the `labgate-results` MCP tools to record and revisit important outcomes.');
-        lines.push('- Available tools: `list_results`, `register_result`, `get_result`, `update_result`, `delete_result`');
-        lines.push('- Use `register_result` sparingly. Do not auto-register routine progress updates or intermediate notes.');
-        lines.push('- Register a result only when the user explicitly asks to save it, or when it is manuscript-grade evidence likely needed later (for example p-values, effect sizes, confidence intervals, benchmark deltas, or a key figure/table output path).');
-        lines.push('- If uncertain whether to register, ask the user first.');
-        lines.push('');
-        lines.push('### Display Widgets');
-        lines.push('- Use the `labgate-display` MCP tool `display_widget` to render rich interactive content in the LabGate web UI.');
-        lines.push('- Supported widgets: `markdown`, `table`, `plot`, `image`, `pdf`, `molecule`, `sequence`, `alignment`, `file_preview`, `tree`, `heatmap`, `tracks`, `domains`, `network`');
-        lines.push('- Use `molecule` with `pdb_id` to show 3D protein structures (e.g. `{ pdb_id: "2HIU" }`).');
-        lines.push('- Use `sequence` to display colored DNA/RNA/protein sequences.');
-        lines.push('- Use `plot` with a Plotly.js spec (`{ plotly: { data: [...], layout: {...} } }`) for interactive charts.');
-        lines.push('- Use `table` for structured data (`{ columns: [...], rows: [...] }`).');
-        lines.push('- Use `image` with `path` to display images from the filesystem.');
-        lines.push('- Use `pdf` with `path` to display PDF documents inline (`{ path: "/work/paper.pdf" }`).');
-        lines.push('- Use `alignment` for multiple sequence alignments with conservation highlighting.');
-        lines.push('- Use `tree` with Newick format string for phylogenetic trees (e.g. `{ newick: "((A,B),(C,D));" }`).');
-        lines.push('- Use `heatmap` for clustered heatmaps with optional dendrograms (`{ matrix: [[...]], row_labels: [...], cluster_rows: true }`).');
-        lines.push('- Use `tracks` for genome feature viewing via igv.js (`{ tracks: [{ path: "/work/file.gff3", format: "gff3" }] }`).');
-        lines.push('- Use `domains` for protein domain architecture (`{ length: 300, features: [{ type: "domain", name: "Kinase", start: 10, end: 120 }] }`).');
-        lines.push('- Use `network` for interactive graph visualization (`{ nodes: [{id:"A"}], edges: [{source:"A", target:"B"}] }`).');
-        lines.push('- Prefer `display_widget` over plain text when showing structured data, sequences, or molecular information.');
+        if (datasetsPluginEnabled) {
+            lines.push('### Dataset Management');
+            lines.push('- Use the `labgate-datasets` MCP tools to manage and explore datasets.');
+            lines.push('- Available tools: `list_datasets`, `inspect_dataset`, `search_dataset`, `get_dataset_summary`, `read_dataset_file`, `validate_dataset`, `register_dataset`, `update_dataset`, `unregister_dataset`');
+            lines.push('- Use `register_dataset` to add new host directories as named datasets.');
+            lines.push('');
+        }
     }
     if (session.config.slurm.enabled) {
         lines.push('');
         lines.push('### SLURM Integration');
         lines.push('- SLURM commands (srun, sbatch, squeue, scancel) are available.');
         lines.push('- LabGate tracks your SLURM jobs automatically via squeue polling.');
-        if (session.config.slurm.mcp_server && hasMcp) {
+        if (slurmPluginEnabled && session.config.slurm.mcp_server && hasMcp) {
             lines.push('- Use the `labgate-cluster` MCP tools to inspect partitions, queue pressure, and available modules.');
             lines.push('- Available tools: `get_cluster_partitions`, `get_partition_limits`, `get_queue_pressure`, `find_module`');
             lines.push('- Use the `labgate-slurm` MCP tools to check job status and read output files.');
@@ -335,172 +321,320 @@ function serializeCodexMcpToml(servers) {
     }
     return lines.join('\n');
 }
-function prepareMcpServers(session, options = {}) {
-    const agentLower = session.agent.toLowerCase();
-    if (agentLower !== 'claude' && agentLower !== 'codex')
-        return;
+const MCP_STAGE_STAMP_FILE = '.labgate-stage-stamp';
+const STARTUP_STAGE_LOCK_DIR = 'startup-stage.lock';
+function getStartupStageLockPath(sandboxHome) {
+    return (0, path_1.join)(sandboxHome, '.labgate', 'locks', STARTUP_STAGE_LOCK_DIR);
+}
+function syncMcpBundleFile(sourcePath, targetPath) {
+    if (!(0, fs_1.existsSync)(sourcePath))
+        return false;
+    const source = (0, fs_1.readFileSync)(sourcePath);
     try {
-        const sandboxHome = (0, config_js_1.getSandboxHome)();
-        const mcpDir = (0, path_1.join)(sandboxHome, '.mcp-servers');
-        (0, fs_1.mkdirSync)(mcpDir, { recursive: true });
-        // Claude Code reads MCP config from ~/.claude.json (in HOME root).
-        // For Codex we build the same mcpConfig object, then serialize to TOML below.
-        const mcpConfigPath = (0, path_1.join)(sandboxHome, '.claude.json');
-        let mcpConfig = {};
+        if ((0, fs_1.existsSync)(targetPath)) {
+            const target = (0, fs_1.readFileSync)(targetPath);
+            if (source.equals(target))
+                return true;
+        }
+    }
+    catch {
+        // Fall through to overwrite.
+    }
+    (0, startup_stage_lock_js_1.writeTextFileAtomic)(targetPath, source, { mode: config_js_1.PRIVATE_FILE_MODE });
+    (0, config_js_1.ensurePrivateFile)(targetPath);
+    return true;
+}
+function writePrivateFileIfChanged(path, content) {
+    try {
+        if ((0, fs_1.existsSync)(path) && (0, fs_1.readFileSync)(path, 'utf-8') === content)
+            return;
+    }
+    catch {
+        // Fall through to rewrite.
+    }
+    (0, startup_stage_lock_js_1.writeTextFileAtomic)(path, content, { mode: config_js_1.PRIVATE_FILE_MODE });
+    (0, config_js_1.ensurePrivateFile)(path);
+}
+function updateMcpPackageStampFromDir(hash, rootDir, relativeDir = '') {
+    const dirPath = relativeDir ? (0, path_1.join)(rootDir, relativeDir) : rootDir;
+    const entries = (0, fs_1.readdirSync)(dirPath).sort((a, b) => a.localeCompare(b));
+    for (const entry of entries) {
+        const relativePath = relativeDir ? (0, path_1.join)(relativeDir, entry) : entry;
+        const normalizedRelativePath = relativePath.replace(/\\/g, '/');
+        const absPath = (0, path_1.join)(rootDir, relativePath);
+        const st = (0, fs_1.lstatSync)(absPath);
+        if (st.isDirectory()) {
+            hash.update(`dir:${normalizedRelativePath}\n`);
+            updateMcpPackageStampFromDir(hash, rootDir, relativePath);
+            continue;
+        }
+        if (st.isSymbolicLink()) {
+            hash.update(`link:${normalizedRelativePath}\n`);
+            hash.update((0, fs_1.readlinkSync)(absPath));
+            hash.update('\n');
+            continue;
+        }
+        if (!st.isFile())
+            continue;
+        hash.update(`file:${normalizedRelativePath}\n`);
+        hash.update((0, fs_1.readFileSync)(absPath));
+        hash.update('\n');
+    }
+}
+function computeMcpPackageStamp(sourceDir) {
+    if (!(0, fs_1.existsSync)(sourceDir))
+        return null;
+    try {
+        const hash = (0, crypto_1.createHash)('sha256');
+        updateMcpPackageStampFromDir(hash, sourceDir);
+        return hash.digest('hex');
+    }
+    catch {
+        return null;
+    }
+}
+function syncMcpPackageDir(sourceDir, targetDir) {
+    const stamp = computeMcpPackageStamp(sourceDir);
+    if (!stamp)
+        return false;
+    const stampPath = (0, path_1.join)(targetDir, MCP_STAGE_STAMP_FILE);
+    let targetIsSymlink = false;
+    try {
+        targetIsSymlink = (0, fs_1.lstatSync)(targetDir).isSymbolicLink();
+    }
+    catch {
+        targetIsSymlink = false;
+    }
+    try {
+        if ((0, fs_1.existsSync)(targetDir) && (0, fs_1.existsSync)(stampPath)) {
+            const currentStamp = (0, fs_1.readFileSync)(stampPath, 'utf-8').trim();
+            if (currentStamp === stamp && targetIsSymlink)
+                return true;
+        }
+    }
+    catch {
+        // Fall through to recopy.
+    }
+    const parentDir = (0, path_1.dirname)(targetDir);
+    const packageName = (0, path_1.basename)(targetDir);
+    const storeRoot = (0, path_1.join)(parentDir, '.labgate-store');
+    const storeDir = (0, path_1.join)(storeRoot, packageName);
+    const stagedDir = (0, path_1.join)(storeDir, stamp);
+    const tempStageDir = (0, path_1.join)(storeDir, `.tmp-${process.pid}-${(0, crypto_1.randomBytes)(6).toString('hex')}`);
+    const tempLinkPath = (0, path_1.join)(parentDir, `.${packageName}.tmp-link-${(0, crypto_1.randomBytes)(6).toString('hex')}`);
+    try {
+        (0, config_js_1.ensurePrivateDir)(storeRoot);
+        (0, config_js_1.ensurePrivateDir)(storeDir);
+    }
+    catch {
+        return false;
+    }
+    if (!(0, fs_1.existsSync)(stagedDir)) {
         try {
-            if ((0, fs_1.existsSync)(mcpConfigPath)) {
-                mcpConfig = JSON.parse((0, fs_1.readFileSync)(mcpConfigPath, 'utf-8'));
-            }
+            (0, fs_1.cpSync)(sourceDir, tempStageDir, { recursive: true, force: true });
+            const stagedStampPath = (0, path_1.join)(tempStageDir, MCP_STAGE_STAMP_FILE);
+            (0, fs_1.writeFileSync)(stagedStampPath, `${stamp}\n`, { encoding: 'utf-8', mode: config_js_1.PRIVATE_FILE_MODE });
+            (0, config_js_1.ensurePrivateFile)(stagedStampPath);
+            (0, fs_1.renameSync)(tempStageDir, stagedDir);
         }
-        catch { /* start fresh */ }
-        if (!mcpConfig.mcpServers)
-            mcpConfig.mcpServers = {};
-        const env = {
-            LABGATE_CONFIG_PATH: '/labgate-config/config.json',
-            LABGATE_CONTAINER_MODE: '1',
-        };
-        const copyMcpNodePackage = (pkgName) => {
-            const sourceDir = (0, path_1.resolve)(__dirname, '../../node_modules', pkgName);
-            if (!(0, fs_1.existsSync)(sourceDir))
+        catch {
+            try {
+                (0, fs_1.rmSync)(tempStageDir, { recursive: true, force: true });
+            }
+            catch { /* ignore */ }
+            if (!(0, fs_1.existsSync)(stagedDir))
                 return false;
-            const targetDir = (0, path_1.join)(mcpDir, 'node_modules', pkgName);
-            (0, fs_1.cpSync)(sourceDir, targetDir, { recursive: true, force: true });
+        }
+    }
+    try {
+        (0, fs_1.symlinkSync)(stagedDir, tempLinkPath, 'dir');
+    }
+    catch {
+        return false;
+    }
+    let targetExists = false;
+    try {
+        (0, fs_1.lstatSync)(targetDir);
+        targetExists = true;
+    }
+    catch {
+        targetExists = false;
+    }
+    if (targetExists && targetIsSymlink) {
+        try {
+            const currentTarget = (0, path_1.resolve)(parentDir, (0, fs_1.readlinkSync)(targetDir));
+            if (currentTarget === stagedDir) {
+                (0, fs_1.rmSync)(tempLinkPath, { force: true });
+                return true;
+            }
+        }
+        catch {
+            // Fall through to replace the current symlink.
+        }
+    }
+    try {
+        if (!targetExists || targetIsSymlink) {
+            (0, fs_1.renameSync)(tempLinkPath, targetDir);
             return true;
-        };
-        const stageSlurmMcpRuntimeDeps = () => {
-            (0, config_js_1.ensurePrivateDir)((0, path_1.join)(mcpDir, 'node_modules'));
-            // better-sqlite3 resolves through bindings -> file-uri-to-path at runtime.
-            return (copyMcpNodePackage('better-sqlite3') &&
-                copyMcpNodePackage('bindings') &&
-                copyMcpNodePackage('file-uri-to-path'));
-        };
-        // Dataset MCP server (always)
-        const datasetBundleSrc = (0, path_1.resolve)(__dirname, '../mcp-bundles/dataset-mcp.bundle.mjs');
-        if ((0, fs_1.existsSync)(datasetBundleSrc)) {
-            (0, fs_1.copyFileSync)(datasetBundleSrc, (0, path_1.join)(mcpDir, 'dataset-mcp.bundle.mjs'));
-            mcpConfig.mcpServers['labgate-datasets'] = {
-                command: 'node',
-                args: ['/home/sandbox/.mcp-servers/dataset-mcp.bundle.mjs'],
-                env,
-            };
         }
-        else {
-            // Fallback: host path (development without bundles)
-            const datasetMcpPath = (0, path_1.resolve)(__dirname, 'dataset-mcp.js');
-            mcpConfig.mcpServers['labgate-datasets'] = {
-                command: 'node',
-                args: [datasetMcpPath],
-            };
+        const legacyTargetDir = (0, path_1.join)(parentDir, `.${packageName}.legacy-${(0, crypto_1.randomBytes)(6).toString('hex')}`);
+        (0, fs_1.renameSync)(targetDir, legacyTargetDir);
+        try {
+            (0, fs_1.renameSync)(tempLinkPath, targetDir);
         }
-        // Results MCP server (always)
-        const resultsBundleSrc = (0, path_1.resolve)(__dirname, '../mcp-bundles/results-mcp.bundle.mjs');
-        if ((0, fs_1.existsSync)(resultsBundleSrc)) {
-            (0, fs_1.copyFileSync)(resultsBundleSrc, (0, path_1.join)(mcpDir, 'results-mcp.bundle.mjs'));
-            mcpConfig.mcpServers['labgate-results'] = {
-                command: 'node',
-                args: ['/home/sandbox/.mcp-servers/results-mcp.bundle.mjs', '--db', '/labgate-config/results.json'],
-                env,
-            };
+        catch (err) {
+            (0, fs_1.renameSync)(legacyTargetDir, targetDir);
+            throw err;
         }
-        else {
-            const resultsMcpPath = (0, path_1.resolve)(__dirname, 'results-mcp.js');
-            mcpConfig.mcpServers['labgate-results'] = {
-                command: 'node',
-                args: [resultsMcpPath, '--db', (0, config_js_1.getResultsDbPath)()],
-            };
+        (0, fs_1.rmSync)(legacyTargetDir, { recursive: true, force: true });
+        return true;
+    }
+    catch {
+        try {
+            (0, fs_1.rmSync)(tempLinkPath, { force: true });
         }
-        // Display MCP server (always — renders rich widgets in LabGate UI)
-        const displayBundleSrc = (0, path_1.resolve)(__dirname, '../mcp-bundles/display-mcp.bundle.mjs');
-        if ((0, fs_1.existsSync)(displayBundleSrc)) {
-            (0, fs_1.copyFileSync)(displayBundleSrc, (0, path_1.join)(mcpDir, 'display-mcp.bundle.mjs'));
-            mcpConfig.mcpServers['labgate-display'] = {
-                command: 'node',
-                args: ['/home/sandbox/.mcp-servers/display-mcp.bundle.mjs', '--db', '/labgate-config/display.json'],
-                env,
+        catch { /* ignore */ }
+        return false;
+    }
+}
+function prepareMcpServers(session, options = {}) {
+    const agentLower = session.agent.toLowerCase();
+    if (agentLower !== 'claude' && agentLower !== 'codex')
+        return;
+    try {
+        const sandboxHome = (0, config_js_1.getSandboxHome)();
+        (0, config_js_1.ensurePrivateDir)((0, path_1.join)(sandboxHome, '.labgate'));
+        (0, config_js_1.ensurePrivateDir)((0, path_1.join)(sandboxHome, '.labgate', 'locks'));
+        (0, startup_stage_lock_js_1.withStartupStageLock)(getStartupStageLockPath(sandboxHome), 'mcp-stage', () => {
+            const mcpDir = (0, path_1.join)(sandboxHome, '.mcp-servers');
+            (0, fs_1.mkdirSync)(mcpDir, { recursive: true });
+            // Claude Code reads MCP config from ~/.claude.json (in HOME root).
+            // For Codex we build the same mcpConfig object, then serialize to TOML below.
+            const mcpConfigPath = (0, path_1.join)(sandboxHome, '.claude.json');
+            let mcpConfig = {};
+            try {
+                if ((0, fs_1.existsSync)(mcpConfigPath)) {
+                    mcpConfig = JSON.parse((0, fs_1.readFileSync)(mcpConfigPath, 'utf-8'));
+                }
+            }
+            catch { /* start fresh */ }
+            if (!mcpConfig.mcpServers)
+                mcpConfig.mcpServers = {};
+            const env = {
+                LABGATE_CONFIG_PATH: '/labgate-config/config.json',
+                LABGATE_CONTAINER_MODE: '1',
             };
-        }
-        else {
-            const displayMcpPath = (0, path_1.resolve)(__dirname, 'display-mcp.js');
-            mcpConfig.mcpServers['labgate-display'] = {
-                command: 'node',
-                args: [displayMcpPath, '--db', (0, config_js_1.getDisplayDbPath)()],
+            const datasetsPluginEnabled = session.config.plugins?.datasets !== false;
+            const slurmPluginEnabled = session.config.plugins?.slurm !== false;
+            const copyMcpNodePackage = (pkgName) => {
+                const sourceDir = options.resolveMcpPackageDir?.(pkgName) ?? (0, path_1.resolve)(__dirname, '../../node_modules', pkgName);
+                const targetDir = (0, path_1.join)(mcpDir, 'node_modules', pkgName);
+                return syncMcpPackageDir(sourceDir, targetDir);
             };
-        }
-        // Cluster MCP server (when SLURM integration is enabled and plugin active)
-        const slurmPluginEnabled = session.config.plugins?.slurm !== false;
-        if (session.config.slurm.enabled && session.config.slurm.mcp_server && slurmPluginEnabled) {
-            const clusterBundleSrc = (0, path_1.resolve)(__dirname, '../mcp-bundles/cluster-mcp.bundle.mjs');
-            if ((0, fs_1.existsSync)(clusterBundleSrc)) {
-                (0, fs_1.copyFileSync)(clusterBundleSrc, (0, path_1.join)(mcpDir, 'cluster-mcp.bundle.mjs'));
-                mcpConfig.mcpServers['labgate-cluster'] = {
-                    command: 'node',
-                    args: ['/home/sandbox/.mcp-servers/cluster-mcp.bundle.mjs'],
-                    env,
-                };
+            const stageSlurmMcpRuntimeDeps = () => {
+                (0, config_js_1.ensurePrivateDir)((0, path_1.join)(mcpDir, 'node_modules'));
+                // better-sqlite3 resolves through bindings -> file-uri-to-path at runtime.
+                return (copyMcpNodePackage('better-sqlite3') &&
+                    copyMcpNodePackage('bindings') &&
+                    copyMcpNodePackage('file-uri-to-path'));
+            };
+            if (datasetsPluginEnabled) {
+                const datasetBundleSrc = (0, path_1.resolve)(__dirname, '../mcp-bundles/dataset-mcp.bundle.mjs');
+                if (syncMcpBundleFile(datasetBundleSrc, (0, path_1.join)(mcpDir, 'dataset-mcp.bundle.mjs'))) {
+                    mcpConfig.mcpServers['labgate-datasets'] = {
+                        command: 'node',
+                        args: ['/home/sandbox/.mcp-servers/dataset-mcp.bundle.mjs'],
+                        env,
+                    };
+                }
+                else {
+                    // Fallback: host path (development without bundles)
+                    const datasetMcpPath = (0, path_1.resolve)(__dirname, 'dataset-mcp.js');
+                    mcpConfig.mcpServers['labgate-datasets'] = {
+                        command: 'node',
+                        args: [datasetMcpPath],
+                    };
+                }
             }
             else {
-                const clusterMcpPath = (0, path_1.resolve)(__dirname, 'cluster-mcp.js');
-                mcpConfig.mcpServers['labgate-cluster'] = {
-                    command: 'node',
-                    args: [clusterMcpPath],
-                };
+                delete mcpConfig.mcpServers['labgate-datasets'];
             }
-        }
-        else {
-            delete mcpConfig.mcpServers['labgate-cluster'];
-        }
-        // SLURM MCP server (when enabled and plugin active)
-        if (session.config.slurm.enabled && session.config.slurm.mcp_server && slurmPluginEnabled) {
-            const slurmBundleSrc = (0, path_1.resolve)(__dirname, '../mcp-bundles/slurm-mcp.bundle.mjs');
-            if ((0, fs_1.existsSync)(slurmBundleSrc)) {
-                const staged = options.stageSlurmDeps ? options.stageSlurmDeps() : stageSlurmMcpRuntimeDeps();
-                if (staged) {
-                    (0, fs_1.copyFileSync)(slurmBundleSrc, (0, path_1.join)(mcpDir, 'slurm-mcp.bundle.mjs'));
-                    mcpConfig.mcpServers['labgate-slurm'] = {
+            delete mcpConfig.mcpServers['labgate-results'];
+            delete mcpConfig.mcpServers['labgate-display'];
+            // Cluster MCP server (when SLURM integration is enabled and plugin active)
+            if (session.config.slurm.enabled && session.config.slurm.mcp_server && slurmPluginEnabled) {
+                const clusterBundleSrc = (0, path_1.resolve)(__dirname, '../mcp-bundles/cluster-mcp.bundle.mjs');
+                if (syncMcpBundleFile(clusterBundleSrc, (0, path_1.join)(mcpDir, 'cluster-mcp.bundle.mjs'))) {
+                    mcpConfig.mcpServers['labgate-cluster'] = {
                         command: 'node',
-                        args: ['/home/sandbox/.mcp-servers/slurm-mcp.bundle.mjs', '--db', '/labgate-config/slurm.db'],
+                        args: ['/home/sandbox/.mcp-servers/cluster-mcp.bundle.mjs'],
                         env,
                     };
                 }
                 else {
-                    delete mcpConfig.mcpServers['labgate-slurm'];
+                    const clusterMcpPath = (0, path_1.resolve)(__dirname, 'cluster-mcp.js');
+                    mcpConfig.mcpServers['labgate-cluster'] = {
+                        command: 'node',
+                        args: [clusterMcpPath],
+                    };
                 }
             }
             else {
-                const mcpServerPath = (0, path_1.resolve)(__dirname, 'slurm-mcp.js');
-                const dbPath = (0, config_js_1.getSlurmDbPath)();
-                mcpConfig.mcpServers['labgate-slurm'] = {
-                    command: 'node',
-                    args: [mcpServerPath, '--db', dbPath],
-                };
+                delete mcpConfig.mcpServers['labgate-cluster'];
             }
-        }
-        else {
-            delete mcpConfig.mcpServers['labgate-slurm'];
-        }
-        if (agentLower === 'claude') {
-            (0, fs_1.writeFileSync)(mcpConfigPath, JSON.stringify(mcpConfig, null, 2), 'utf-8');
-            (0, config_js_1.ensurePrivateFile)(mcpConfigPath);
-        }
-        if (agentLower === 'codex') {
-            // Codex reads MCP config from ~/.codex/config.toml
-            const codexDir = (0, path_1.join)(sandboxHome, '.codex');
-            (0, fs_1.mkdirSync)(codexDir, { recursive: true });
-            const codexConfigPath = (0, path_1.join)(codexDir, 'config.toml');
-            let existingToml = '';
-            try {
-                if ((0, fs_1.existsSync)(codexConfigPath)) {
-                    existingToml = (0, fs_1.readFileSync)(codexConfigPath, 'utf-8');
+            // SLURM MCP server (when enabled and plugin active)
+            if (session.config.slurm.enabled && session.config.slurm.mcp_server && slurmPluginEnabled) {
+                const slurmBundleSrc = (0, path_1.resolve)(__dirname, '../mcp-bundles/slurm-mcp.bundle.mjs');
+                if ((0, fs_1.existsSync)(slurmBundleSrc)) {
+                    const staged = options.stageSlurmDeps ? options.stageSlurmDeps() : stageSlurmMcpRuntimeDeps();
+                    if (staged) {
+                        syncMcpBundleFile(slurmBundleSrc, (0, path_1.join)(mcpDir, 'slurm-mcp.bundle.mjs'));
+                        mcpConfig.mcpServers['labgate-slurm'] = {
+                            command: 'node',
+                            args: ['/home/sandbox/.mcp-servers/slurm-mcp.bundle.mjs', '--db', '/labgate-config/slurm.db'],
+                            env,
+                        };
+                    }
+                    else {
+                        delete mcpConfig.mcpServers['labgate-slurm'];
+                    }
+                }
+                else {
+                    const mcpServerPath = (0, path_1.resolve)(__dirname, 'slurm-mcp.js');
+                    const dbPath = (0, config_js_1.getSlurmDbPath)();
+                    mcpConfig.mcpServers['labgate-slurm'] = {
+                        command: 'node',
+                        args: [mcpServerPath, '--db', dbPath],
+                    };
                 }
             }
-            catch { /* start fresh */ }
-            // Strip old [mcp_servers.*] sections and append fresh ones
-            const cleaned = stripTomlMcpSections(existingToml);
-            const mcpToml = serializeCodexMcpToml(mcpConfig.mcpServers);
-            const separator = cleaned.length > 0 && !cleaned.endsWith('\n') ? '\n\n' : cleaned.length > 0 ? '\n' : '';
-            (0, fs_1.writeFileSync)(codexConfigPath, cleaned + separator + mcpToml, 'utf-8');
-            (0, config_js_1.ensurePrivateFile)(codexConfigPath);
-        }
+            else {
+                delete mcpConfig.mcpServers['labgate-slurm'];
+            }
+            if (agentLower === 'claude') {
+                const nextClaudeConfig = JSON.stringify(mcpConfig, null, 2);
+                writePrivateFileIfChanged(mcpConfigPath, nextClaudeConfig);
+            }
+            if (agentLower === 'codex') {
+                // Codex reads MCP config from ~/.codex/config.toml
+                const codexDir = (0, path_1.join)(sandboxHome, '.codex');
+                (0, fs_1.mkdirSync)(codexDir, { recursive: true });
+                const codexConfigPath = (0, path_1.join)(codexDir, 'config.toml');
+                let existingToml = '';
+                try {
+                    if ((0, fs_1.existsSync)(codexConfigPath)) {
+                        existingToml = (0, fs_1.readFileSync)(codexConfigPath, 'utf-8');
+                    }
+                }
+                catch { /* start fresh */ }
+                // Strip old [mcp_servers.*] sections and append fresh ones
+                const cleaned = stripTomlMcpSections(existingToml);
+                const mcpToml = serializeCodexMcpToml(mcpConfig.mcpServers);
+                const separator = cleaned.length > 0 && !cleaned.endsWith('\n') ? '\n\n' : cleaned.length > 0 ? '\n' : '';
+                const nextCodexConfig = cleaned + separator + mcpToml;
+                writePrivateFileIfChanged(codexConfigPath, nextCodexConfig);
+            }
+        });
     }
     catch {
         // Best effort — MCP registration failure is non-fatal
@@ -567,32 +701,92 @@ function cleanStaleSessionFiles() {
 // ── SIF image management (Apptainer) ─────────────────────
 /**
  * Convert a container image URI to a local SIF filename.
- * e.g. "docker.io/library/ubuntu:22.04" → "docker.io_library_ubuntu_22.04.sif"
+ * Includes a short hash suffix so distinct image refs cannot collide after sanitization.
  */
 function imageToSifName(image) {
-    return image.replace(/[/:]/g, '_') + '.sif';
+    const normalized = String(image || '').trim();
+    const readable = normalized
+        .replace(/[^a-zA-Z0-9._-]+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .slice(0, 160) || 'image';
+    const hash = (0, crypto_1.createHash)('sha256').update(normalized).digest('hex').slice(0, 12);
+    return `${readable}-${hash}.sif`;
+}
+const APPTAINER_SIF_INSPECT_TIMEOUT_MS = 15_000;
+function isUsableApptainerSif(runtime, sifPath) {
+    if (!(0, fs_1.existsSync)(sifPath))
+        return false;
+    try {
+        (0, child_process_1.execFileSync)(runtime, ['inspect', sifPath], {
+            stdio: 'ignore',
+            timeout: APPTAINER_SIF_INSPECT_TIMEOUT_MS,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
 }
 /**
  * Ensure a SIF image exists in the cache directory.
  * Pulls from docker:// URI if not already cached.
  */
-function ensureSifImage(runtime, image) {
+async function ensureSifImage(runtime, image) {
     const imagesDir = (0, config_js_1.getImagesDir)();
     (0, fs_1.mkdirSync)(imagesDir, { recursive: true });
     const sifPath = (0, path_1.join)(imagesDir, imageToSifName(image));
-    if ((0, fs_1.existsSync)(sifPath)) {
+    const pullLockPath = `${sifPath}.pull.lock`;
+    if (isUsableApptainerSif(runtime, sifPath) && !(0, fs_1.existsSync)(pullLockPath)) {
         return sifPath;
     }
-    log.info(`Pulling image ${log.dim(image)}`);
     try {
-        (0, child_process_1.execFileSync)(runtime, ['pull', sifPath, `docker://${image}`], {
-            stdio: 'inherit',
+        await (0, image_pull_lock_js_1.withImagePullFileLock)(pullLockPath, image, async () => {
+            if (isUsableApptainerSif(runtime, sifPath))
+                return;
+            if ((0, fs_1.existsSync)(sifPath)) {
+                log.warn(`Cached SIF for ${log.dim(image)} failed validation. Re-pulling image.`);
+                try {
+                    (0, fs_1.rmSync)(sifPath, { force: true });
+                }
+                catch {
+                    // Best effort; the pull below will surface remaining problems.
+                }
+            }
+            const tempSifPath = `${sifPath}.tmp-${process.pid}-${(0, crypto_1.randomBytes)(6).toString('hex')}`;
+            log.info(`Pulling image ${log.dim(image)}`);
+            try {
+                (0, child_process_1.execFileSync)(runtime, ['pull', tempSifPath, `docker://${image}`], {
+                    stdio: 'inherit',
+                });
+                if (!isUsableApptainerSif(runtime, tempSifPath)) {
+                    throw new Error(`Pulled SIF failed validation: ${tempSifPath}`);
+                }
+                (0, fs_1.renameSync)(tempSifPath, sifPath);
+            }
+            finally {
+                try {
+                    (0, fs_1.rmSync)(tempSifPath, { force: true });
+                }
+                catch {
+                    // Best effort cleanup for failed or interrupted pulls.
+                }
+            }
+        }, {
+            onWait: ({ owner }) => {
+                const ownerLabel = owner && owner !== 'unknown' ? ` (owner: ${owner})` : '';
+                log.step(`Waiting for shared image pull lock for ${log.dim(image)}${ownerLabel}...`);
+            },
+            onStaleLockRemoved: ({ ageMs, owner }) => {
+                const ageSec = Math.max(1, Math.round(ageMs / 1000));
+                const ownerLabel = owner && owner !== 'unknown' ? ` (owner: ${owner})` : '';
+                log.warn(`Recovered stale image pull lock for ${log.dim(image)} after ${ageSec}s${ownerLabel}.`);
+            },
         });
     }
     catch (err) {
         const msg = err?.stderr?.toString?.() ?? err?.message ?? String(err);
         log.error(`Failed to pull SIF image "${image}" with ${runtime}.`);
-        console.error(msg.trim().slice(0, 500));
+        console.error(String(msg).trim().slice(0, 500));
         process.exit(1);
     }
     return sifPath;
@@ -681,6 +875,21 @@ function getMountRoots(session) {
         }),
     ];
 }
+function getSlurmProxyMountRoots(session) {
+    const { workdir, config } = session;
+    return [
+        { host: workdir, container: '/work' },
+        ...config.filesystem.extra_paths.map(({ path: p }) => {
+            const resolved = p.replace(/^~/, (0, os_1.homedir)());
+            const target = `/mnt/${(0, path_1.basename)(resolved)}`;
+            return { host: resolved, container: target };
+        }),
+        ...(config.datasets || []).map(({ path: p, name }) => {
+            const resolved = p.replace(/^~/, (0, os_1.homedir)());
+            return { host: resolved, container: `/datasets/${name}` };
+        }),
+    ];
+}
 // ── SLURM host proxy (container wrappers -> host execution) ────────
 const SLURM_PROXY_COMMANDS = new Set([
     'srun',
@@ -692,31 +901,122 @@ const SLURM_PROXY_COMMANDS = new Set([
     'scontrol',
 ]);
 const SLURM_PROXY_SOCKET_IN_CONTAINER = '/home/sandbox/.labgate/slurm/host-proxy/slurm.sock';
-function mapContainerPathToHost(session, containerPath) {
-    const mounts = getMountRoots(session).sort((a, b) => b.container.length - a.container.length);
+const SLURM_PROXY_PATH_VALUE_OPTIONS = new Set([
+    '--chdir',
+    '--output',
+    '--error',
+    '--input',
+    '-D',
+    '-o',
+    '-e',
+    '-i',
+]);
+function normalizeSlurmProxyContainerCwd(containerCwd) {
+    const raw = String(containerCwd || '').trim();
+    if (!raw)
+        return '/work';
+    return raw.startsWith('/')
+        ? path_1.posix.resolve('/', raw)
+        : path_1.posix.resolve('/work', raw);
+}
+function buildSlurmProxyBlockedPathError(rawPath, resolvedPath) {
+    return (`Path blocked by SLURM host proxy: ${rawPath} resolves to ${resolvedPath}. ` +
+        'Use /work, /mnt/*, or /datasets/* paths.');
+}
+function isLikelyRelativeSlurmPathArg(arg) {
+    const trimmed = String(arg || '').trim();
+    if (!trimmed || trimmed.startsWith('-'))
+        return false;
+    if (trimmed === '.' || trimmed === '..')
+        return true;
+    if (trimmed.startsWith('./') || trimmed.startsWith('../'))
+        return true;
+    return trimmed.includes('/');
+}
+function resolveSlurmProxyPathToHost(session, candidatePath, containerCwd = '/work') {
+    const raw = String(candidatePath || '').trim();
+    if (!raw)
+        return null;
+    const normalizedCwd = normalizeSlurmProxyContainerCwd(containerCwd);
+    const normalizedPath = raw.startsWith('/')
+        ? path_1.posix.resolve('/', raw)
+        : path_1.posix.resolve(normalizedCwd, raw);
+    const mounts = getSlurmProxyMountRoots(session).sort((a, b) => b.container.length - a.container.length);
     for (const mount of mounts) {
-        if (containerPath === mount.container)
+        if (normalizedPath === mount.container)
             return mount.host;
         const prefix = `${mount.container}/`;
-        if (containerPath.startsWith(prefix)) {
-            return (0, path_1.join)(mount.host, containerPath.slice(prefix.length));
+        if (normalizedPath.startsWith(prefix)) {
+            return (0, path_1.join)(mount.host, normalizedPath.slice(prefix.length));
         }
     }
-    return containerPath;
+    return null;
 }
-function mapProxyArgToHostPath(session, arg) {
-    if (arg.startsWith('/')) {
-        return mapContainerPathToHost(session, arg);
+function mapSlurmProxyArgToHostPath(session, arg, containerCwd) {
+    const trimmed = String(arg || '').trim();
+    if (!trimmed) {
+        return { ok: true, arg };
     }
     const eq = arg.indexOf('=');
     if (eq > 0) {
-        const key = arg.slice(0, eq + 1);
+        const key = arg.slice(0, eq);
         const value = arg.slice(eq + 1);
-        if (value.startsWith('/')) {
-            return `${key}${mapContainerPathToHost(session, value)}`;
+        const shouldMapValue = (SLURM_PROXY_PATH_VALUE_OPTIONS.has(key) ||
+            value.startsWith('/') ||
+            value === '.' ||
+            value === '..' ||
+            value.startsWith('./') ||
+            value.startsWith('../'));
+        if (!shouldMapValue) {
+            return { ok: true, arg };
+        }
+        const mapped = resolveSlurmProxyPathToHost(session, value, containerCwd);
+        if (!mapped) {
+            const resolved = value.startsWith('/')
+                ? path_1.posix.resolve('/', value)
+                : path_1.posix.resolve(normalizeSlurmProxyContainerCwd(containerCwd), value);
+            return { ok: false, error: buildSlurmProxyBlockedPathError(value, resolved) };
+        }
+        return { ok: true, arg: `${key}=${mapped}` };
+    }
+    if (arg.startsWith('/')) {
+        const mapped = resolveSlurmProxyPathToHost(session, arg, containerCwd);
+        if (!mapped) {
+            return { ok: false, error: buildSlurmProxyBlockedPathError(arg, path_1.posix.resolve('/', arg)) };
         }
+        return { ok: true, arg: mapped };
     }
-    return arg;
+    if (isLikelyRelativeSlurmPathArg(arg)) {
+        const mapped = resolveSlurmProxyPathToHost(session, arg, containerCwd);
+        if (!mapped) {
+            const resolved = path_1.posix.resolve(normalizeSlurmProxyContainerCwd(containerCwd), arg);
+            return { ok: false, error: buildSlurmProxyBlockedPathError(arg, resolved) };
+        }
+        return { ok: true, arg: mapped };
+    }
+    return { ok: true, arg };
+}
+function mapSlurmProxyArgsToHost(session, args, containerCwd) {
+    const mappedArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = String(args[i] || '');
+        if (SLURM_PROXY_PATH_VALUE_OPTIONS.has(arg) && i + 1 < args.length) {
+            const nextArg = String(args[i + 1] || '');
+            const mappedValue = resolveSlurmProxyPathToHost(session, nextArg, containerCwd);
+            if (!mappedValue) {
+                const resolved = path_1.posix.resolve(normalizeSlurmProxyContainerCwd(containerCwd), nextArg);
+                return { ok: false, error: buildSlurmProxyBlockedPathError(nextArg, resolved) };
+            }
+            mappedArgs.push(arg, mappedValue);
+            i += 1;
+            continue;
+        }
+        const mapped = mapSlurmProxyArgToHostPath(session, arg, containerCwd);
+        if (!mapped.ok)
+            return mapped;
+        mappedArgs.push(mapped.arg);
+    }
+    return { ok: true, args: mappedArgs };
 }
 function startSlurmHostProxy(session) {
     const sandboxHome = (0, config_js_1.getSandboxHome)();
@@ -775,11 +1075,29 @@ function startSlurmHostProxy(session) {
                 return;
             }
             const args = Array.isArray(req.args) ? req.args.map(v => String(v)) : [];
-            const mappedArgs = args.map(arg => mapProxyArgToHostPath(session, arg));
             const requestedCwd = String(req.cwd || '').trim();
-            const mappedCwd = requestedCwd
-                ? mapContainerPathToHost(session, requestedCwd)
-                : session.workdir;
+            const containerCwd = normalizeSlurmProxyContainerCwd(requestedCwd || '/work');
+            const mappedCwd = resolveSlurmProxyPathToHost(session, containerCwd, '/work');
+            if (!mappedCwd) {
+                send({
+                    ok: false,
+                    exit_code: 126,
+                    stdout_b64: '',
+                    stderr_b64: Buffer.from(buildSlurmProxyBlockedPathError(requestedCwd || '/work', containerCwd)).toString('base64'),
+                });
+                return;
+            }
+            const mappedArgsResult = mapSlurmProxyArgsToHost(session, args, containerCwd);
+            if (!mappedArgsResult.ok) {
+                send({
+                    ok: false,
+                    exit_code: 126,
+                    stdout_b64: '',
+                    stderr_b64: Buffer.from(mappedArgsResult.error).toString('base64'),
+                });
+                return;
+            }
+            const mappedArgs = mappedArgsResult.args;
             const stdoutChunks = [];
             const stderrChunks = [];
             const child = (0, child_process_1.spawn)(cmd, mappedArgs, {
@@ -959,6 +1277,7 @@ const CODEX_OAUTH_STARTUP_HEARTBEAT_MS = 10_000;
 const CODEX_OAUTH_STARTUP_HEARTBEAT_MAX_MS = 50_000;
 const CODEX_OAUTH_STARTUP_SPINNER_MS = 125;
 const CODEX_OAUTH_STARTUP_SPINNER_FRAMES = ['|', '/', '-', '\\'];
+const DEFERRED_SLURM_PASSTHROUGH_DELAY_MS = 1_500;
 function getCodexOauthCallbackPort() {
     const raw = (process.env.LABGATE_CODEX_OAUTH_CALLBACK_PORT || '').trim();
     if (!raw)
@@ -1053,6 +1372,7 @@ function startCodexOauthStartupHeartbeat() {
 // ── Build Apptainer arguments ─────────────────────────────
 function buildApptainerArgs(session, sifPath, sessionId, tokenEnv = []) {
     const { agent, workdir, config } = session;
+    const ensureCommands = session.config.commands.ensure_commands;
     const sandboxHome = (0, config_js_1.getSandboxHome)();
     const { blockedMounts, emptyDir, envArgs } = prepareCommonArgs(session, sessionId, tokenEnv);
     const resultsDbPath = ensureResultsDbPathForContainer();
@@ -1110,7 +1430,7 @@ function buildApptainerArgs(session, sifPath, sessionId, tokenEnv = []) {
         // ── SIF image ──
         sifPath,
         // ── Entrypoint ──
-        'bash', '-lc', buildEntrypoint(agent),
+        'bash', '-lc', buildEntrypoint(agent, { ensureCommands }),
     ];
 }
 function getPodmanContainerName(sessionId) {
@@ -1118,6 +1438,7 @@ function getPodmanContainerName(sessionId) {
 }
 function buildPodmanArgs(session, image, sessionId, tokenEnv = [], options = { tty: false }) {
     const { agent, workdir, config } = session;
+    const ensureCommands = session.config.commands.ensure_commands;
     const disableClaudeStatusLineForPodmanDarwin = agent === 'claude' && (0, os_1.platform)() === 'darwin';
     const sandboxHome = (0, config_js_1.getSandboxHome)();
     const { blockedMounts, emptyDir, envArgs } = prepareCommonArgs(session, sessionId, tokenEnv);
@@ -1177,7 +1498,10 @@ function buildPodmanArgs(session, image, sessionId, tokenEnv = [], options = { t
         ...envArgs,
         // ── Image + entrypoint ──
         image,
-        'bash', '-lc', buildEntrypoint(agent, { disableClaudeStatusLine: disableClaudeStatusLineForPodmanDarwin }),
+        'bash', '-lc', buildEntrypoint(agent, {
+            disableClaudeStatusLine: disableClaudeStatusLineForPodmanDarwin,
+            ensureCommands,
+        }),
     ];
 }
 // ── Entrypoint script (inline) ───────────────────────────
@@ -1204,6 +1528,10 @@ function buildEntrypoint(agent, options = {}) {
         || disableClaudeStatusLineFlag === 'yes'
         || disableClaudeStatusLineFlag === 'on');
     const disableClaudeStatusLine = options.disableClaudeStatusLine === true || disableClaudeStatusLineFromEnv;
+    const ensureCommandListRaw = options.ensureCommands === undefined ? ['git'] : options.ensureCommands;
+    const ensureCommands = Array.from(new Set((Array.isArray(ensureCommandListRaw) ? ensureCommandListRaw : [])
+        .map((value) => String(value || '').trim())
+        .filter((value) => /^[a-zA-Z0-9._+-]+$/.test(value))));
     const lines = [
         'set -euo pipefail',
         'export HOME=/home/sandbox',
@@ -1291,9 +1619,13 @@ function buildEntrypoint(agent, options = {}) {
     ];
     const preLaunchLines = [];
     if (agent === 'claude') {
-        preLaunchLines.push('labgate_ensure_git() {', '  if command -v git >/dev/null 2>&1; then', '    return 0', '  fi', '  if [ "$(id -u)" != "0" ]; then', '    echo "[labgate] Warning: git is missing in this container. Claude marketplace requires git." >&2', '    echo "[labgate] Configure an image with git installed (for example docker.io/library/node:20-bookworm)." >&2', '    return 0', '  fi', '  echo "[labgate] Installing git for Claude marketplace support..."', '  if command -v apt-get >/dev/null 2>&1; then', '    export DEBIAN_FRONTEND=noninteractive', '    apt-get update >/dev/null 2>&1 || return 0', '    apt-get install -y git >/dev/null 2>&1 || return 0', '  elif command -v apk >/dev/null 2>&1; then', '    apk add --no-cache git >/dev/null 2>&1 || return 0', '  elif command -v dnf >/dev/null 2>&1; then', '    dnf install -y git >/dev/null 2>&1 || return 0', '  elif command -v yum >/dev/null 2>&1; then', '    yum install -y git >/dev/null 2>&1 || return 0', '  elif command -v microdnf >/dev/null 2>&1; then', '    microdnf install -y git >/dev/null 2>&1 || return 0', '  fi', '  if ! command -v git >/dev/null 2>&1; then', '    echo "[labgate] Warning: git is still unavailable; Claude marketplace may stay disabled." >&2', '  fi', '}', 'labgate_ensure_git', '');
+        if (ensureCommands.length > 0) {
+            preLaunchLines.push('labgate_install_system_package() {', '  local manager="${1:-}"', '  local pkg="${2:-}"', '  [ -n "$manager" ] && [ -n "$pkg" ] || return 1', '  case "$manager" in', '    apt-get) apt-get install -y "$pkg" >/dev/null 2>&1 ;;', '    apk) apk add --no-cache "$pkg" >/dev/null 2>&1 ;;', '    dnf) dnf install -y "$pkg" >/dev/null 2>&1 ;;', '    yum) yum install -y "$pkg" >/dev/null 2>&1 ;;', '    microdnf) microdnf install -y "$pkg" >/dev/null 2>&1 ;;', '    *) return 1 ;;', '  esac', '}', 'labgate_candidate_packages_for_command() {', '  local cmd="${1:-}"', '  case "$cmd" in', '    rg) echo "ripgrep rg" ;;', '    fd) echo "fd-find fd" ;;', '    pip) echo "python3-pip py3-pip pip" ;;', '    python) echo "python3 python" ;;', '    *) echo "$cmd" ;;', '  esac', '}', 'labgate_ensure_commands() {', `  local required=(${ensureCommands.map((cmd) => JSON.stringify(cmd)).join(' ')})`, '  local missing=()', '  local cmd=""', '  for cmd in "${required[@]}"; do', '    if ! command -v "$cmd" >/dev/null 2>&1; then', '      missing+=("$cmd")', '    fi', '  done', '  if [ "${#missing[@]}" -eq 0 ]; then', '    return 0', '  fi', '  if [ "$(id -u)" != "0" ]; then', '    echo "[labgate] Warning: missing container command(s): ${missing[*]}." >&2', '    echo "[labgate] Configure an image with required tools preinstalled for best Claude UX." >&2', '    return 0', '  fi', '  local manager=""', '  if command -v apt-get >/dev/null 2>&1; then', '    manager="apt-get"', '    export DEBIAN_FRONTEND=noninteractive', '    apt-get update >/dev/null 2>&1 || true', '  elif command -v apk >/dev/null 2>&1; then', '    manager="apk"', '  elif command -v dnf >/dev/null 2>&1; then', '    manager="dnf"', '  elif command -v yum >/dev/null 2>&1; then', '    manager="yum"', '  elif command -v microdnf >/dev/null 2>&1; then', '    manager="microdnf"', '  fi', '  if [ -z "$manager" ]; then', '    echo "[labgate] Warning: cannot install missing commands (${missing[*]}); no known package manager found." >&2', '    return 0', '  fi', '  echo "[labgate] Installing missing container tools: ${missing[*]}..."', '  local candidate=""', '  local installed="0"', '  for cmd in "${missing[@]}"; do', '    installed="0"', '    for candidate in $(labgate_candidate_packages_for_command "$cmd"); do', '      if labgate_install_system_package "$manager" "$candidate"; then', '        installed="1"', '        if command -v "$cmd" >/dev/null 2>&1; then', '          break', '        fi', '      fi', '    done', '    if [ "$installed" != "1" ]; then', '      echo "[labgate] Warning: failed to install command ${cmd}." >&2', '    fi', '  done', '  local still_missing=()', '  for cmd in "${required[@]}"; do', '    if ! command -v "$cmd" >/dev/null 2>&1; then', '      still_missing+=("$cmd")', '    fi', '  done', '  if [ "${#still_missing[@]}" -gt 0 ]; then', '    echo "[labgate] Warning: command(s) still unavailable after install attempt: ${still_missing[*]}." >&2', '    echo "[labgate] Configure an image with these tools preinstalled for reliable startup." >&2', '  fi', '}', 'labgate_ensure_commands', '');
+        }
         if (disableClaudeStatusLine) {
-            lines.push('mkdir -p "$HOME/.claude"', 'rm -f "$HOME/.claude/labgate-statusline.sh" 2>/dev/null || true', 'node -e \'', '  const fs = require("fs");', '  const path = process.env.HOME + "/.claude/settings.json";', '  let settings = {};', '  try {', '    if (fs.existsSync(path)) settings = JSON.parse(fs.readFileSync(path, "utf8"));', '  } catch {}', '  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {', '    settings = {};', '  }', '  // LabGate may disable Claude status lines for specific environments.', '  // Remove both camelCase and lowercase variants for compatibility.', '  delete settings.statusLine;', '  delete settings.statusline;', '  fs.writeFileSync(path, JSON.stringify(settings, null, 2));', '\'', '');
+            // Set the statusLine to a no-op command so Claude Code renders an empty
+            // status bar instead of falling back to its default "time ➜ at host |".
+            lines.push('mkdir -p "$HOME/.claude"', 'rm -f "$HOME/.claude/labgate-statusline.sh" 2>/dev/null || true', 'node -e \'', '  const fs = require("fs");', '  const path = process.env.HOME + "/.claude/settings.json";', '  let settings = {};', '  try {', '    if (fs.existsSync(path)) settings = JSON.parse(fs.readFileSync(path, "utf8"));', '  } catch {}', '  if (!settings || typeof settings !== "object" || Array.isArray(settings)) {', '    settings = {};', '  }', '  delete settings.statusline;', '  settings.statusLine = { type: "command", command: "true" };', '  fs.writeFileSync(path, JSON.stringify(settings, null, 2));', '\'', '');
         }
         else {
             // Configure a LabGate status line in Claude Code with a dashboard URL.
@@ -1352,13 +1684,25 @@ let lastHandledOAuthAt = 0;
 const CLAUDE_OAUTH_MARKER = 'https://claude.ai/oauth/authorize?';
 const CLAUDE_MANUAL_CODE_REDIRECT_URI = 'https://platform.claude.com/oauth/code/callback';
 const CLAUDE_LOCALHOST_REDIRECT_HOSTS = new Set(['localhost', '127.0.0.1', '[::1]', '::1']);
+const CLAUDE_AUTH_FALLBACK_URL_RE = /https:\/\/[A-Za-z0-9.-]+\/[^\s"'<>]+/g;
 function stripTerminalControlForOAuth(text) {
-    return String(text || '')
+    const source = String(text || '');
+    const osc8Urls = [];
+    const osc8Re = /\x1b\]8;[^\x07\x1b]*?;([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
+    for (const match of source.matchAll(osc8Re)) {
+        const candidate = String(match[1] || '').trim();
+        if (candidate)
+            osc8Urls.push(candidate);
+    }
+    let stripped = source
         .replace(/\x1b\][\s\S]*?(?:\x07|\x1b\\)/g, '')
         .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
         .replace(/\x1b[P^_][\s\S]*?\x1b\\/g, '')
         .replace(/\x1b[@-_]/g, '')
         .replace(/[\u0000-\u0008\u000b-\u001f\u007f]/g, '');
+    if (osc8Urls.length)
+        stripped += `\n${osc8Urls.join('\n')}`;
+    return stripped;
 }
 function canonicalizeClaudeOAuthRedirectUri(parsed) {
     const rawRedirectUri = (parsed.searchParams.get('redirect_uri') || '').trim();
@@ -1375,45 +1719,84 @@ function canonicalizeClaudeOAuthRedirectUri(parsed) {
         // Keep original redirect URI if it cannot be parsed.
     }
 }
-function normalizeClaudeOAuthUrl(raw) {
-    const stripped = stripTerminalControlForOAuth(raw);
-    const start = stripped.lastIndexOf(CLAUDE_OAUTH_MARKER);
-    if (start === -1)
-        return null;
-    let candidate = stripped.slice(start);
-    const endPatterns = [/\n\s*Paste code/i, /\n\s*Browser did(?: not|n't) open\?/i, /\n\s*\n/];
-    let end = candidate.length;
-    for (const pat of endPatterns) {
-        const match = candidate.match(pat);
-        if (match && match.index !== undefined && match.index >= 0 && match.index < end) {
-            end = match.index;
-        }
-    }
-    candidate = candidate.slice(0, end).replace(/\s+/g, '').trim();
-    const urlMatch = candidate.match(/^https:\/\/claude\.ai\/oauth\/authorize\?[A-Za-z0-9\-._~%!$&'()*+,;=:@/?#[\]]+/);
-    if (!urlMatch)
+function isClaudeAuthHost(hostname) {
+    const host = String(hostname || '').trim().toLowerCase();
+    return host === 'claude.ai' || host === 'platform.claude.com' || host === 'console.anthropic.com';
+}
+function isLikelyClaudeAuthPath(pathname) {
+    const path = String(pathname || '').trim().toLowerCase();
+    if (!path)
+        return false;
+    return path.startsWith('/oauth')
+        || path.startsWith('/login')
+        || path.startsWith('/auth')
+        || path.startsWith('/code/callback');
+}
+function hasValidClaudeAuthorizeParams(parsed) {
+    const required = ['client_id', 'state', 'response_type', 'redirect_uri', 'scope', 'code_challenge', 'code_challenge_method'];
+    for (const key of required) {
+        if (!parsed.searchParams.get(key))
+            return false;
+    }
+    if ((parsed.searchParams.get('response_type') || '').trim().toLowerCase() !== 'code')
+        return false;
+    if ((parsed.searchParams.get('code_challenge_method') || '').trim().toUpperCase() !== 'S256')
+        return false;
+    return true;
+}
+function normalizeClaudeAuthUrlCandidate(candidate) {
+    if (!candidate)
         return null;
     try {
-        const parsed = new URL(urlMatch[0]);
-        if (parsed.protocol !== 'https:' || parsed.hostname !== 'claude.ai' || parsed.pathname !== '/oauth/authorize') {
+        const parsed = new URL(String(candidate || '').trim());
+        if (parsed.protocol !== 'https:')
             return null;
-        }
-        const required = ['client_id', 'state', 'response_type', 'redirect_uri', 'scope', 'code_challenge', 'code_challenge_method'];
-        for (const key of required) {
-            if (!parsed.searchParams.get(key))
-                return null;
-        }
-        if ((parsed.searchParams.get('response_type') || '').trim().toLowerCase() !== 'code')
+        if (!isClaudeAuthHost(parsed.hostname))
             return null;
-        if ((parsed.searchParams.get('code_challenge_method') || '').trim().toUpperCase() !== 'S256')
+        if (!isLikelyClaudeAuthPath(parsed.pathname))
             return null;
-        canonicalizeClaudeOAuthRedirectUri(parsed);
+        if (parsed.hostname.toLowerCase() === 'claude.ai' && parsed.pathname === '/oauth/authorize') {
+            if (!hasValidClaudeAuthorizeParams(parsed))
+                return null;
+            canonicalizeClaudeOAuthRedirectUri(parsed);
+        }
         return parsed.toString();
     }
     catch {
         return null;
     }
 }
+function normalizeClaudeOAuthUrl(raw) {
+    const stripped = stripTerminalControlForOAuth(raw);
+    if (!stripped)
+        return null;
+    const start = stripped.lastIndexOf(CLAUDE_OAUTH_MARKER);
+    if (start !== -1) {
+        let candidate = stripped.slice(start);
+        const endPatterns = [/\n\s*Paste code/i, /\n\s*Browser did(?: not|n't) open\?/i, /\n\s*\n/];
+        let end = candidate.length;
+        for (const pat of endPatterns) {
+            const match = candidate.match(pat);
+            if (match && match.index !== undefined && match.index >= 0 && match.index < end) {
+                end = match.index;
+            }
+        }
+        candidate = candidate.slice(0, end).replace(/\s+/g, '').trim();
+        const strictMatch = candidate.match(/^https:\/\/claude\.ai\/oauth\/authorize\?[A-Za-z0-9\-._~%!$&'()*+,;=:@/?#[\]]+/);
+        if (strictMatch && strictMatch[0]) {
+            const strictUrl = normalizeClaudeAuthUrlCandidate(strictMatch[0]);
+            if (strictUrl)
+                return strictUrl;
+        }
+    }
+    const fallbackMatches = stripped.match(CLAUDE_AUTH_FALLBACK_URL_RE) || [];
+    for (const match of fallbackMatches) {
+        const normalized = normalizeClaudeAuthUrlCandidate(match);
+        if (normalized)
+            return normalized;
+    }
+    return null;
+}
 function handleOAuthUrl(url, options) {
     const normalizedUrl = normalizeClaudeOAuthUrl(url);
     if (!normalizedUrl)
@@ -1506,8 +1889,11 @@ function setupBrowserHook(options = {}) {
         '  esac',
         'done',
         '[ -n "$url" ] || url="${1:-}"',
-        'mkdir -p /home/sandbox/.labgate',
-        'printf \'%s\\n\' "$url" > /home/sandbox/.labgate/browser-url',
+        'targets="/home/sandbox/.labgate/browser-url /home/sandbox/.labgate/ai-home/.labgate/browser-url"',
+        'for t in $targets; do',
+        '  mkdir -p "$(dirname "$t")"',
+        '  printf \'%s\\n\' "$url" > "$t"',
+        'done',
         'exit 0',
         '',
     ].join('\n'), { mode: 0o755 });
@@ -1613,49 +1999,18 @@ function renderStickyFooter(line) {
 /**
  * Resolve agent credentials. Checks in order:
  *   1. Explicit --api-key flag (passed via apiKey parameter)
- *   2. macOS keychain (Claude Code OAuth tokens, Claude only)
- *   3. ANTHROPIC_API_KEY in host environment
+ *   2. ANTHROPIC_API_KEY in host environment
  *
  * Returns env args to inject into the container.
  */
 function getAgentTokenEnv(agent, apiKey, deps = {}) {
     const env = deps.env ?? process.env;
-    const platformFn = deps.platformFn ?? os_1.platform;
-    const execSync = deps.execFileSyncFn ?? child_process_1.execFileSync;
-    const ensureDir = deps.mkdirSyncFn ?? fs_1.mkdirSync;
-    const writeFile = deps.writeFileSyncFn ?? fs_1.writeFileSync;
     // 1. Explicit API key from CLI flag
     if (apiKey) {
         log.success('Using API key from --api-key flag');
         return ['--env', `ANTHROPIC_API_KEY=${apiKey}`];
     }
-    // 2. macOS keychain extraction (local only, Claude)
-    // Sync credentials file into sandbox home, but do not export ANTHROPIC_API_KEY.
-    // Claude may prompt interactively when a custom ANTHROPIC_API_KEY is present,
-    // which can stall UI launches.
-    if (platformFn() === 'darwin' && agent === 'claude') {
-        try {
-            const raw = execSync('security', [
-                'find-generic-password',
-                '-s', 'Claude Code-credentials',
-                '-w',
-            ], { encoding: 'utf-8', timeout: 5000 }).trim();
-            const creds = JSON.parse(raw);
-            const token = creds.claudeAiOauth?.accessToken;
-            if (token) {
-                const sandboxHome = deps.sandboxHome ?? (0, config_js_1.getSandboxHome)();
-                const claudeDir = (0, path_1.join)(sandboxHome, '.claude');
-                ensureDir(claudeDir, { recursive: true });
-                writeFile((0, path_1.join)(claudeDir, '.credentials.json'), raw, { mode: 0o600 });
-                log.success('Synced credentials from macOS keychain');
-                return [];
-            }
-        }
-        catch {
-            // Fall through to host env var fallback.
-        }
-    }
-    // 3. Forward ANTHROPIC_API_KEY from host environment
+    // 2. Forward ANTHROPIC_API_KEY from host environment
     if (env.ANTHROPIC_API_KEY) {
         log.success('Forwarding ANTHROPIC_API_KEY from environment');
         return ['--env', `ANTHROPIC_API_KEY=${env.ANTHROPIC_API_KEY}`];
@@ -1669,6 +2024,22 @@ function formatStatusFooter(session, runtime, sessionId, image) {
     const net = session.config.network.mode;
     return `labgate | ${sessionId} | ${runtime} | net=${net} | timeout=${timeoutLabel} | audit=${audit}`;
 }
+function formatStartupDuration(ms) {
+    const rounded = Math.max(0, Math.round(ms));
+    if (rounded < 1000)
+        return `${rounded}ms`;
+    if (rounded < 10_000)
+        return `${(rounded / 1000).toFixed(1)}s`;
+    return `${Math.round(rounded / 1000)}s`;
+}
+function logStartupTimings(entries, totalMs) {
+    const summary = entries
+        .filter(([, ms]) => Number.isFinite(ms) && ms >= 0)
+        .map(([label, ms]) => `${label}=${formatStartupDuration(ms)}`)
+        .join(', ');
+    const prefix = summary ? `${summary}, ` : '';
+    log.step(`[labgate] startup timings: ${prefix}total=${formatStartupDuration(totalMs)}`);
+}
 // ── Shared session helpers ─────────────────────────────────
 function logSessionStart(session, sessionId) {
     if (!session.config.audit.enabled)
@@ -1764,13 +2135,18 @@ function printSessionInfo(session, sessionId, runtime) {
 }
 // ── Session lifecycle ─────────────────────────────────────
 async function startSession(session) {
+    const startupStartedAt = Date.now();
+    const startupTimings = [];
+    const recordStartupTiming = (label, startedAt) => {
+        startupTimings.push([label, Math.max(0, Date.now() - startedAt)]);
+    };
     const preferred = session.config.runtime;
     const runtime = session.dryRun ? getDryRunRuntime(preferred) : (0, runtime_js_1.getRuntime)(preferred);
     const image = session.imageOverride ?? session.config.image;
     const sessionId = (0, crypto_1.randomBytes)(4).toString('hex');
     const footerMode = session.footerMode ?? 'sticky';
     const footerLine = formatStatusFooter(session, runtime, sessionId, image);
-    // Extract agent auth token (CLI flag → env var → macOS keychain)
+    // Extract agent auth token (CLI flag → env var)
     const tokenEnv = session.dryRun ? [] : getAgentTokenEnv(session.agent, session.apiKey);
     const bridgeCodexOauthForPodman = runtime === 'podman' && shouldBridgeCodexOauthForPodman(session.agent, session.config.network.mode);
     const needsCodexOauthStartupHeartbeat = bridgeCodexOauthForPodman && tokenEnv.length === 0;
@@ -1803,6 +2179,8 @@ async function startSession(session) {
         ...(browserHook?.env ?? []),
     ];
     let cleanupSlurmHostProxy = () => { };
+    let cleanupDeferredSlurmPassthrough = () => { };
+    let startDeferredSlurmPassthrough = () => { };
     // If the agent isn't installed in the persistent sandbox home yet, warn that first run can be slow.
     if (!session.dryRun) {
         const sandboxHome = (0, config_js_1.getSandboxHome)();
@@ -1819,31 +2197,113 @@ async function startSession(session) {
     // can work out of the box when present on the host. Full SLURM tracking/MCP
     // remains controlled by slurm.enabled.
     if (!session.dryRun && runtime === 'apptainer') {
+        const hostProxyStartedAt = Date.now();
         const hostProxy = startSlurmHostProxy(session);
+        recordStartupTiming('slurm_host_proxy', hostProxyStartedAt);
+        const trackingEnabled = session.config.slurm.enabled;
+        const runSlurmPassthroughStage = (mode) => {
+            const stageStartedAt = Date.now();
+            try {
+                const staged = (0, slurm_cli_passthrough_js_1.stageSlurmCliPassthrough)({
+                    sandboxHome: (0, config_js_1.getSandboxHome)(),
+                    env: process.env,
+                    installMissingWrappers: trackingEnabled,
+                    hostProxySocketInContainer: null,
+                    preferHostProxy: false,
+                });
+                recordStartupTiming(mode === 'startup' ? 'slurm_passthrough_stage' : 'slurm_passthrough_stage_background', stageStartedAt);
+                if (trackingEnabled) {
+                    if (!staged.ok) {
+                        log.warn('SLURM is enabled but no SLURM commands were found on the host PATH. ' +
+                            'Inside-sandbox SLURM commands (squeue/sbatch/...) will be unavailable.');
+                    }
+                    else if (staged.reused) {
+                        log.step(mode === 'startup'
+                            ? `SLURM passthrough reused cached stage (${staged.staged.length} commands).`
+                            : `SLURM passthrough reused cached stage in background (${staged.staged.length} commands).`);
+                    }
+                    else if (staged.errors.length > 0) {
+                        log.step(mode === 'startup'
+                            ? `SLURM passthrough staged (${staged.staged.length} commands) with warnings.`
+                            : `SLURM passthrough staged in background (${staged.staged.length} commands) with warnings.`);
+                    }
+                    else {
+                        log.step(mode === 'startup'
+                            ? `SLURM passthrough staged (${staged.staged.length} commands).`
+                            : `SLURM passthrough staged in background (${staged.staged.length} commands).`);
+                    }
+                }
+            }
+            catch (err) {
+                recordStartupTiming(mode === 'startup' ? 'slurm_passthrough_stage' : 'slurm_passthrough_stage_background', stageStartedAt);
+                log.warn(mode === 'startup'
+                    ? `SLURM passthrough staging failed: ${err?.message ?? String(err)}`
+                    : `Deferred SLURM passthrough staging failed: ${err?.message ?? String(err)}`);
+            }
+        };
         if (hostProxy) {
             cleanupSlurmHostProxy = hostProxy.cleanup;
             log.step('SLURM host proxy enabled (wrappers delegate to host CLI).');
+            const stageStartedAt = Date.now();
+            const staged = (0, slurm_cli_passthrough_js_1.stageSlurmCliPassthrough)({
+                sandboxHome: (0, config_js_1.getSandboxHome)(),
+                env: process.env,
+                installMissingWrappers: true,
+                hostProxySocketInContainer: hostProxy.socketContainerPath,
+                preferHostProxy: true,
+            });
+            recordStartupTiming('slurm_passthrough_stage', stageStartedAt);
+            if (trackingEnabled) {
+                if (!staged.ok) {
+                    log.warn('SLURM is enabled but no SLURM commands were found on the host PATH. ' +
+                        'Inside-sandbox SLURM commands (squeue/sbatch/...) will be unavailable.');
+                }
+                else if (staged.mode === 'proxy-only') {
+                    log.step(staged.reused
+                        ? `SLURM passthrough reused host-proxy stage (${staged.hostCommands.length} commands).`
+                        : `SLURM passthrough configured via host proxy (${staged.hostCommands.length} commands).`);
+                }
+                else if (staged.reused) {
+                    log.step(`SLURM passthrough reused cached stage (${staged.staged.length} commands).`);
+                }
+                else if (staged.errors.length > 0) {
+                    log.step(`SLURM passthrough staged (${staged.staged.length} commands) with warnings.`);
+                }
+                else {
+                    log.step(`SLURM passthrough staged (${staged.staged.length} commands).`);
+                }
+            }
         }
         else {
-            log.warn('SLURM host proxy unavailable; wrappers will use in-container staged binaries only.');
-        }
-        const trackingEnabled = session.config.slurm.enabled;
-        const staged = (0, slurm_cli_passthrough_js_1.stageSlurmCliPassthrough)({
-            sandboxHome: (0, config_js_1.getSandboxHome)(),
-            env: process.env,
-            installMissingWrappers: trackingEnabled || !!hostProxy,
-            hostProxySocketInContainer: hostProxy?.socketContainerPath ?? null,
-        });
-        if (trackingEnabled) {
-            if (!staged.ok) {
-                log.warn('SLURM is enabled but no SLURM commands were found on the host PATH. ' +
-                    'Inside-sandbox SLURM commands (squeue/sbatch/...) will be unavailable.');
-            }
-            else if (staged.errors.length > 0) {
-                log.step(`SLURM passthrough staged (${staged.staged.length} commands) with warnings.`);
+            if (trackingEnabled) {
+                log.step('SLURM host proxy unavailable. Staging SLURM passthrough before startup.');
+                runSlurmPassthroughStage('startup');
             }
             else {
-                log.step(`SLURM passthrough staged (${staged.staged.length} commands).`);
+                log.step('SLURM host proxy unavailable. Deferring SLURM passthrough staging until after startup.');
+                let cancelled = false;
+                let timer = null;
+                let started = false;
+                startDeferredSlurmPassthrough = () => {
+                    if (started || cancelled)
+                        return;
+                    started = true;
+                    timer = setTimeout(() => {
+                        timer = null;
+                        if (cancelled)
+                            return;
+                        runSlurmPassthroughStage('background');
+                    }, DEFERRED_SLURM_PASSTHROUGH_DELAY_MS);
+                    timer.unref();
+                };
+                cleanupDeferredSlurmPassthrough = () => {
+                    cancelled = true;
+                    if (timer) {
+                        clearTimeout(timer);
+                        timer = null;
+                    }
+                    started = true;
+                };
             }
         }
     }
@@ -1854,7 +2314,7 @@ async function startSession(session) {
             sifPath = (0, path_1.join)((0, config_js_1.getImagesDir)(), imageToSifName(image));
         }
         else {
-            sifPath = ensureSifImage(runtime, image);
+            sifPath = await ensureSifImage(runtime, image);
         }
         args = buildApptainerArgs(session, sifPath, sessionId, runtimeEnvArgs);
     }
@@ -1917,7 +2377,10 @@ async function startSession(session) {
         }
     }
     // Register MCP servers for Claude Code (bundled for in-container use)
+    const prepareMcpStartedAt = Date.now();
     prepareMcpServers(session);
+    recordStartupTiming('prepare_mcp_servers', prepareMcpStartedAt);
+    logStartupTimings(startupTimings, Date.now() - startupStartedAt);
     logSessionStart(session, sessionId);
     printSessionInfo(session, sessionId, runtime);
     if (footerMode === 'once') {
@@ -2017,6 +2480,7 @@ async function startSession(session) {
                         clearTimeout(timeoutHandle);
                     browserHook?.cleanup();
                     cleanupSlurm();
+                    cleanupDeferredSlurmPassthrough();
                     cleanupSlurmHostProxy();
                     removeSessionFile(sessionId, session.sharedSessionsDir);
                     cleanupLabgateInstruction();
@@ -2030,6 +2494,7 @@ async function startSession(session) {
                 for (const sig of ['SIGINT', 'SIGTERM']) {
                     process.on(sig, () => child.kill(sig));
                 }
+                startDeferredSlurmPassthrough();
                 return;
             }
         }
@@ -2048,12 +2513,14 @@ async function startSession(session) {
     // OAuth interception relies on the BROWSER hook + file watcher here
     // (the PTY path above uses onData for direct interception).
     const child = (0, child_process_1.spawn)(runtime, args, { stdio: 'inherit' });
+    startDeferredSlurmPassthrough();
     const timeoutHandle = setupSessionTimeout(session, sessionId, runtime, () => child.exitCode !== null, () => child.kill('SIGTERM'));
     child.on('close', (code) => {
         if (timeoutHandle)
             clearTimeout(timeoutHandle);
         browserHook?.cleanup();
         cleanupSlurm();
+        cleanupDeferredSlurmPassthrough();
         cleanupSlurmHostProxy();
         removeSessionFile(sessionId, session.sharedSessionsDir);
         cleanupLabgateInstruction();