dsh-plugin-local-infer 0.1.0 → 0.1.2

package/packages/ui/lib/route.js

@@ -12,7 +12,7 @@
  * ~/.dsh/local-infer/config.json, shared with the CLI, so the browser never
  * sees a secret it did not store. The routes are held by an effect, so they
  * go when the plugin does.
- * @module @dsh/dsh-plugin-local-infer/ui/route
+ * @module dsh-plugin-local-infer/ui/route
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
@@ -20,8 +20,8 @@ import { dirname, join } from 'node:path';
 // Relative, not the root package subpath: a self-referencing bare specifier
 // only resolves when the package sits inside a node_modules tree, so a
 // local-path or pnpm-linked install of this repo would fail the import.
-import { CHAT_TEMPLATE_FILE, buildModelEntry, checkDeps, DEFAULT_LOG_PATH_TEMPLATE, hfChatTemplateCommand, hfDownloadCommand, launchRecordFromPlan, modelArtifactPath, modelEntriesForEngine, providerIdFor, renderInstallString, resolveLogPath, } from '../../core/lib/index.js';
-import { CHAT_TEMPLATE_OPTIONS, defaultModelFor, defaultModelsForEngine, ENGINES, } from '../../providers/lib/index.js';
+import { CHAT_TEMPLATE_FILE, buildModelEntry, checkDeps, DEFAULT_LOG_PATH_TEMPLATE, formatLaunchCommand, hfChatTemplateCommand, hfDownloadCommand, launchRecordFromPlan, modelArtifactPath, modelEntriesForEngine, providerIdFor, renderInstallString, resolveLogPath, } from '../../core/lib/index.js';
+import { CHAT_TEMPLATE_OPTIONS, buildEngineRepo, defaultModelFor, defaultModelsForEngine, ENGINES, enginePlatformDefaults, infernixGetDownloads, nodeLifecycleHost, syncEngineRepo, } from '../../providers/lib/index.js';
 import { renderDeps } from "./deps.js";
 import { renderForm } from "./form.js";
 import { renderMeter } from "./meter.js";
@@ -241,7 +241,16 @@ function parsePlatformConfigs(raw) {
         if (typeof fields.engineFork === 'string') {
             stored.engineFork = fields.engineFork;
         }
-        if (stored.engineDirectory !== undefined || stored.engineFork !== undefined) {
+        if (typeof fields.buildCommands === 'string') {
+            stored.buildCommands = fields.buildCommands;
+        }
+        if (typeof fields.dockerTag === 'string') {
+            stored.dockerTag = fields.dockerTag;
+        }
+        if (stored.engineDirectory !== undefined ||
+            stored.engineFork !== undefined ||
+            stored.buildCommands !== undefined ||
+            stored.dockerTag !== undefined) {
             platform[engineId] = stored;
         }
     }
@@ -265,11 +274,55 @@ function parseStoredPlatformConfig(raw) {
     if (typeof fields.engineFork === 'string') {
         stored.engineFork = fields.engineFork;
     }
-    if (stored.engineDirectory === undefined && stored.engineFork === undefined) {
+    if (typeof fields.buildCommands === 'string') {
+        stored.buildCommands = fields.buildCommands;
+    }
+    if (typeof fields.dockerTag === 'string') {
+        stored.dockerTag = fields.dockerTag;
+    }
+    if (stored.engineDirectory === undefined &&
+        stored.engineFork === undefined &&
+        stored.buildCommands === undefined &&
+        stored.dockerTag === undefined) {
         return undefined;
     }
     return stored;
 }
+/**
+ * relinkStoredProviders prices every stored provider launch record against the
+ * live process table through the service's re-link rule and returns the
+ * provider list the card should read: an adopted engine is re-marked plugin-
+ * launched and tied to its model by the service, and a liveness watcher starts
+ * on its port so a later pkill settles the stored state through the death
+ * observer without another summary read; a dead engine's record is cleared on
+ * disk here (the previous-pid list with it), so a recycled pid cannot re-link
+ * to a config whose engine is down. The route calls it on mount and the
+ * summary calls it per read, making re-attach independent of the card opening.
+ */
+export async function relinkStoredProviders(localInfer, stored) {
+    const recorded = stored.providers.filter((provider) => provider.launch !== undefined);
+    if (recorded.length === 0)
+        return stored.providers;
+    const outcomes = await localInfer.reLinkProviders(recorded.map((provider) => ({ id: provider.id, record: provider.launch })));
+    if (!recorded.some((provider) => outcomes[provider.id] === 'dead')) {
+        return stored.providers;
+    }
+    const providers = stored.providers.map((provider) => {
+        if (provider.launch === undefined || outcomes[provider.id] !== 'dead') {
+            return provider;
+        }
+        // Rebuild the dead entry without the launch key, so the record (including
+        // the previous-pid list) is gone from the file, not just ignored.
+        return {
+            id: provider.id,
+            engine: provider.engine,
+            config: provider.config,
+            platform: provider.platform,
+        };
+    });
+    writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, providers, stored.logPath, stored.lastLogs);
+    return providers;
+}
 /**
  * buildSummary assembles the card's read model for one engine and config: the
  * static engine and model lists, the detected hardware, the form model the
@@ -359,40 +412,26 @@ export async function buildSummary(localInfer, request) {
     // to init) is re-adopted as plugin-launched, so its status dot reads as
     // running for its model and the OS-reserve resolver keeps the default. A
     // record whose engine is dead is cleared (the previous-pid list with it),
-    // so a recycled pid cannot re-link to a config whose engine is down.
-    const recorded = stored.providers.filter((provider) => provider.launch !== undefined);
-    if (recorded.length > 0) {
-        const outcomes = await localInfer.reLinkProviders(recorded.map((provider) => ({ id: provider.id, record: provider.launch })));
-        if (recorded.some((provider) => outcomes[provider.id] === 'dead')) {
-            const providers = stored.providers.map((provider) => {
-                if (provider.launch === undefined || outcomes[provider.id] !== 'dead') {
-                    return provider;
-                }
-                return {
-                    id: provider.id,
-                    engine: provider.engine,
-                    config: provider.config,
-                    platform: provider.platform,
-                };
-            });
-            writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, providers, stored.logPath, stored.lastLogs);
-        }
-    }
+    // so a recycled pid cannot re-link to a config whose engine is down. The
+    // adopted engines also get a liveness watcher, so a later pkill settles the
+    // stored state without waiting for another summary read.
+    const linkedProviders = await relinkStoredProviders(localInfer, stored);
     // The provider list the card renders as collapsed entries: each saved
     // config's engine and model feed the detector, which resolves the running-
     // state its status dot paints. A provider the detector cannot tie to a
     // confirmed model reads as unsure, so the dot never overstates a live
-    // engine.
-    const providerRefs = stored.providers.map((provider) => {
+    // engine. The config rides into the detector so the signature prices the
+    // provider's own build mode and port, not the adapter's default-port guess.
+    const providerRefs = linkedProviders.map((provider) => {
         const model = typeof provider.config.model === 'string' ? provider.config.model : undefined;
         // exactOptionalPropertyTypes: include the model key only when it is a
         // string, so a config that names no model never writes `undefined`.
         return model !== undefined
-            ? { id: provider.id, engine: provider.engine, model }
-            : { id: provider.id, engine: provider.engine };
+            ? { id: provider.id, engine: provider.engine, model, config: provider.config }
+            : { id: provider.id, engine: provider.engine, config: provider.config };
     });
     const providerStatuses = providerRefs.length > 0 ? await localInfer.providerStatuses(providerRefs) : {};
-    const providers = stored.providers.map((provider) => ({
+    const providers = linkedProviders.map((provider) => ({
         id: provider.id,
         engine: provider.engine,
         model: typeof provider.config.model === 'string' ? provider.config.model : '',
@@ -431,7 +470,23 @@ export async function buildSummary(localInfer, request) {
         // read as unregistered, which hides the Remove button (a no-op removal).
     }
     return {
-        engines: ENGINES.map((entry) => ({ id: entry.id, label: entry.label, supports: entry.supports })),
+        engines: ENGINES.map((entry) => {
+            // The platform defaults ride the engine entry so the card's Engine
+            // platform section seeds the build-command and docker-tag placeholders
+            // from the same data the deploy step consumes.
+            const defaults = enginePlatformDefaults(entry.id);
+            return {
+                id: entry.id,
+                label: entry.label,
+                supports: entry.supports,
+                ...(defaults.defaultBuildCommand !== undefined
+                    ? { defaultBuildCommand: defaults.defaultBuildCommand }
+                    : {}),
+                ...(defaults.defaultDockerTag !== undefined
+                    ? { defaultDockerTag: defaults.defaultDockerTag }
+                    : {}),
+            };
+        }),
         models: localInfer.registeredVramModels().map((model) => ({ id: model.id, source: model.source })),
         hardware,
         engineId: engine.id,
@@ -502,7 +557,10 @@ function setPlatformConfig(localInfer, engineId, config) {
     if (config === undefined) {
         return;
     }
-    if (config.engineDirectory === undefined && config.engineFork === undefined) {
+    if (config.engineDirectory === undefined &&
+        config.engineFork === undefined &&
+        config.buildCommands === undefined &&
+        config.dockerTag === undefined) {
         return;
     }
     const platform = { engineId, ...config };
@@ -670,16 +728,56 @@ function resolveAdapter(localInfer, engineId) {
     }
     return adapter;
 }
+/**
+ * launchCommandNote renders the plan's child-process launch line for the
+ * card's Logs section: the core formatter's command under a [local-infer]
+ * launch prefix, newline-terminated. A plan that names no command (a bare
+ * docker plan with no argv) has no note, and the run logs stay as they are.
+ */
+function launchCommandNote(plan) {
+    const command = formatLaunchCommand(plan);
+    if (command === undefined)
+        return undefined;
+    return `[local-infer] launch: ${command}\n`;
+}
+/**
+ * applyComposeArgs seeds a compose plan's compose arguments from the stored
+ * platform config (the card's docker-tag field for a compose engine, e.g.
+ * `--profile single`), so the up line the deploy runs and the down line the
+ * stop runs both select the profile the user named. A compose plan with no
+ * stored docker-tag keeps the engine's default profile; a non-compose plan is
+ * untouched.
+ */
+function applyComposeArgs(plan, localInfer, engineId) {
+    if (plan.kind !== 'compose')
+        return;
+    const platform = localInfer.enginePlatformConfig(engineId);
+    if (platform?.dockerTag !== undefined) {
+        plan.composeArgs = platform.dockerTag;
+    }
+}
+/**
+ * persistStoredLogs overwrites the stored last-run logs (the card's Logs
+ * section shows them after a reload) and leaves every other stored field as
+ * the launch reads it.
+ */
+function persistStoredLogs(logs) {
+    const stored = readConfig();
+    writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, stored.providers, stored.logPath, logs);
+}
 /**
  * launchEngine renders the plan the registered adapter produces for the config
  * and the detected hardware, then runs the service's launch entry point
  * (deploy, then the health poll). The detail the launch returns names the
- * broken step when the engine does not come up. The launch step persists the
+ * broken step when the engine does not come up. The launch line (the engine
+ * binary and its arguments) leads the run logs the card's Logs section and
+ * the log file carry, so a broken setup diagnoses against the exact child
+ * process the launch started. The launch step persists the
  * launch record (the engine pid, start time, launch arguments, and the DSH
  * process pid that launched it) on the request's provider entry, so a DSH
  * restart can re-link a surviving engine to its config.
  */
-export async function launchEngine(localInfer, request) {
+export async function launchEngine(localInfer, request, onProgress) {
     const stored = readConfig();
     const engineId = request.engine ?? stored.engine;
     const config = request.config ?? stored.config;
@@ -692,7 +790,56 @@ export async function launchEngine(localInfer, request) {
     if (request.platform !== undefined) {
         setPlatformConfig(localInfer, engineId, request.platform);
     }
-    const result = await localInfer.launch(adapter.renderLaunch(config, hardware));
+    const plan = adapter.renderLaunch(config, hardware);
+    applyComposeArgs(plan, localInfer, engineId);
+    const commandNote = launchCommandNote(plan);
+    if (commandNote !== undefined) {
+        // Persist before the deploy starts: a slow or hung launch keeps the
+        // command readable in the Logs section across a card reload, where the
+        // engine output has not landed yet.
+        persistStoredLogs(commandNote);
+    }
+    // The prereqs phase: the system-dependency install the local build needs. It
+    // runs only while the Play/Run trust gate is on, the same rule the Get step
+    // applies; a failed install aborts the launch before the deploy starts. The
+    // card's button reads "Prereqs..." for this phase, so the phase is reported
+    // only while an install actually runs (the gate on), not when the deps are
+    // already satisfied and the phase is skipped.
+    if (stored.allowRunDeps === true) {
+        onProgress?.('prereqs');
+        const buildMode = plan.kind === 'docker' ? 'docker' : 'local';
+        const install = await localInfer.runInstall(engineId, buildMode, hardware);
+        if (!install.ok) {
+            const result = {
+                plan,
+                healthy: false,
+                detail: 'a system dependency install failed',
+            };
+            persistLaunchLogs(result, engineId, config);
+            persistLaunchRecord(result, engineId, config, request.providerId);
+            return result;
+        }
+    }
+    // The trust gate and the auto-rebuild flag ride into the deploy step, which
+    // reads them to decide whether a rebuild's missing-binary symlink into
+    // /usr/local/bin runs (on) or is written to the card's Logs section (off),
+    // and whether the git sync (fetch, rebase, rebuild) runs at all.
+    const result = await localInfer.launch(plan, {
+        ...(onProgress !== undefined ? { onProgress } : {}),
+        allowRunDeps: stored.allowRunDeps,
+        ...(request.autoRebuild !== undefined ? { autoRebuild: request.autoRebuild } : {}),
+    });
+    // Order the run logs: the build output (the rebuild decision, the build
+    // command, and its output) leads, the launch command follows it (after a
+    // successful build, or a direct launch with no build), and the engine's
+    // runtime output comes last. A deploy that failed before the engine printed
+    // anything still reports the command it tried to run.
+    const buildLogs = result.buildLogs ?? '';
+    const engineLogs = result.logs ?? '';
+    result.logs = buildLogs + (commandNote ?? '') + engineLogs;
+    if (result.buildLogs !== undefined) {
+        delete result.buildLogs;
+    }
     persistLaunchLogs(result, engineId, config);
     persistLaunchRecord(result, engineId, config, request.providerId);
     return result;
@@ -756,6 +903,47 @@ function clearLaunchRecord(engineId, config, providerId) {
     });
     writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, providers, stored.logPath, stored.lastLogs);
 }
+/**
+ * handleEngineDeath persists a provider entry's state when its engine process
+ * dies outside the plugin's stop path: a crash, a pkill of a plugin-launched
+ * child seen through the service's exit watch, or the poll-detected exit of a
+ * process adopted after a DSH restart. The entry whose launch record names the
+ * dead pid (or the dead engine-and-port, when the report carries no pid match)
+ * has its record cleared, so a restart never re-links a dead pid, and the exit
+ * line lands in the card's last-run logs beside the engine's own output. An
+ * event that matches no entry carrying a record (a stop the route already
+ * cleared, an engine the plugin never tracked) is a no-op, which keeps an
+ * expected stop quiet.
+ */
+export function handleEngineDeath(event) {
+    const stored = readConfig();
+    let matched = false;
+    const providers = stored.providers.map((entry) => {
+        const record = entry.launch;
+        if (record === undefined)
+            return entry;
+        const byPid = event.pid !== undefined && record.pid === event.pid;
+        const byEnginePort = event.port !== undefined && record.engineId === entry.engine && record.port === event.port;
+        if (!byPid && !byEnginePort)
+            return entry;
+        matched = true;
+        // Rebuild the entry without the launch key, so the record (including the
+        // previous-pid list) is gone from the file, not just ignored.
+        return { id: entry.id, engine: entry.engine, config: entry.config, platform: entry.platform };
+    });
+    if (!matched)
+        return;
+    const signalNote = event.signal !== null && event.signal !== undefined
+        ? ` on signal ${event.signal}`
+        : ` with exit code ${event.code}`;
+    const note = `[local-infer] engine ${event.engineId}` +
+        `${event.port !== undefined ? ` (port ${event.port})` : ''}` +
+        ` pid ${event.pid ?? 'unknown'} exited${signalNote}` +
+        `${event.detail !== undefined ? `: ${event.detail}` : ''}\n`;
+    writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, providers, stored.logPath, 
+    // Keep the last-run tail bounded, the same rule the launch logs cap uses.
+    (stored.lastLogs + note).slice(-65536));
+}
 /**
  * persistLaunchLogs stores a launch's captured output as the last run and
  * writes it to the configured log file. The log file is only written when the
@@ -794,9 +982,143 @@ export async function stopEngine(localInfer, request) {
     const config = request.config ?? stored.config;
     const adapter = resolveAdapter(localInfer, engineId);
     const hardware = await localInfer.detectHardware();
-    await localInfer.stop(adapter.renderLaunch(config, hardware));
+    const plan = adapter.renderLaunch(config, hardware);
+    applyComposeArgs(plan, localInfer, engineId);
+    await localInfer.stop(plan);
     clearLaunchRecord(engineId, config, request.providerId);
 }
+/**
+ * resolveEngineDirectory picks the checkout the Get step syncs: the Engine
+ * Directory override when it names a path, else a per-engine folder inside
+ * the model directory (the default model directory, or the config's
+ * override), so a Get with no override still has a real place to live.
+ */
+function resolveEngineDirectory(localInfer, config, engineId, platform) {
+    const override = platform?.engineDirectory;
+    if (override !== undefined && override.trim() !== '') {
+        return override;
+    }
+    const rawModelDir = config.modelDirectory;
+    const modelDir = typeof rawModelDir === 'string' && rawModelDir.trim() !== ''
+        ? rawModelDir
+        : localInfer.defaultModelDirectory();
+    return join(modelDir, engineId);
+}
+/**
+ * resolveModelDirectory picks the model directory a Get run downloads into:
+ * the config's modelDirectory override when it names a path, else the
+ * plugin's default model directory. The same rule the summary and deps routes
+ * apply, so a Get and the card's Model Directory field agree on the target.
+ */
+function resolveModelDirectory(localInfer, config) {
+    const rawModelDir = config.modelDirectory;
+    return typeof rawModelDir === 'string' && rawModelDir.trim() !== ''
+        ? rawModelDir
+        : localInfer.defaultModelDirectory();
+}
+/**
+ * getEngine is the Get step: it syncs the engine checkout (clone the git
+ * repo, or the fork when the platform entry provides one; fetch and rebase
+ * a clean checkout; abort with a Logs alert when the checkout has local
+ * changes), runs the system dependency plan, and runs the engine's build
+ * steps. Every command and its output streams through log as it lands, so
+ * the card appends it to the Logs section live. The dependency install only
+ * runs while the Play/Run trust gate is on; with the gate off the deps are
+ * re-checked and a missing one aborts the step with the copy/paste note.
+ */
+export async function getEngine(localInfer, request, log, host = nodeLifecycleHost) {
+    const stored = readConfig();
+    const engineId = request.engine ?? stored.engine;
+    const config = request.config ?? stored.config;
+    // ENGINES is a known non-empty constant, so the fallback is always defined.
+    const engine = ENGINES.find((entry) => entry.id === engineId) ?? ENGINES[0];
+    // Register the request's platform override the same way launchEngine does,
+    // so the next launch reads the Engine Directory / Engine Fork the Get used.
+    if (request.platform !== undefined) {
+        setPlatformConfig(localInfer, engineId, request.platform);
+    }
+    const platform = request.platform ?? stored.platform[engineId];
+    const directory = resolveEngineDirectory(localInfer, config, engineId, platform);
+    const fork = platform?.engineFork;
+    log(`get ${engineId} in ${directory}\n`);
+    const sync = await syncEngineRepo(host, { engineId, directory, ...(fork !== undefined && fork.trim() !== '' ? { fork } : {}) }, log);
+    if (!sync.ok) {
+        // A dirty checkout already alerted in the sync step; any other failure
+        // names its step here.
+        if (sync.aborted !== true && sync.detail !== undefined) {
+            log(`!! ${sync.detail}\n`);
+        }
+        return { ok: false, ...(sync.detail !== undefined ? { detail: sync.detail } : {}) };
+    }
+    const hardware = await localInfer.detectHardware();
+    const buildMode = resolveBuildMode(engine, config);
+    log(`system dependencies (${buildMode})\n`);
+    if (stored.allowRunDeps === true) {
+        const result = await localInfer.runInstall(engineId, buildMode, hardware);
+        for (const entry of result.results) {
+            log(`  ${entry.id}: ${entry.status}${entry.detail !== undefined ? ` (${entry.detail})` : ''}\n`);
+        }
+        if (!result.ok) {
+            log('!! a system dependency install failed; copy the install string from the panel\n');
+            return { ok: false, detail: 'a system dependency install failed' };
+        }
+    }
+    else {
+        const deps = await localInfer.deps(engineId, buildMode, hardware);
+        const checks = await checkDeps(deps, hardware);
+        let missing = false;
+        for (const check of checks) {
+            log(`  ${check.dep.id}: ${check.status}\n`);
+            if (check.status !== 'satisfied')
+                missing = true;
+        }
+        if (missing) {
+            log('!! a system dependency is missing and one-click install is off; copy the install string from the panel\n');
+            return { ok: false, detail: 'a system dependency is missing' };
+        }
+    }
+    const build = await buildEngineRepo(host, engineId, directory, log);
+    if (!build.ok) {
+        if (build.detail !== undefined) {
+            log(`!! ${build.detail}\n`);
+        }
+        return { ok: false, ...(build.detail !== undefined ? { detail: build.detail } : {}) };
+    }
+    // The model artifacts a Get leaves ready to launch: the Infernix DFlash2
+    // drafter (when a preset is selected) and the PLE n-gram volume (when the
+    // model key names one), pulled through the hf CLI into the model directory.
+    // A download failure aborts the Get, so a launch never reads a missing
+    // drafter or table.
+    if (engineId === 'infernix') {
+        const modelDir = resolveModelDirectory(localInfer, config);
+        for (const command of infernixGetDownloads(config, modelDir)) {
+            log(`$ ${command}\n`);
+            const outcome = host.runStream !== undefined
+                ? await host.runStream(command, (chunk) => log(chunk))
+                : await host.run(command);
+            if (!outcome.ok) {
+                log(`!! ${command} failed: ${outcome.detail ?? 'unknown'}\n`);
+                return { ok: false, detail: 'a model artifact download failed' };
+            }
+        }
+    }
+    log('get complete\n');
+    return { ok: true };
+}
+/**
+ * persistGetLogs appends one Get run's streamed output to the stored last-
+ * run logs (the card's Logs section shows it after a reload) and writes no
+ * log file: the launch step owns the per-run files. The tail rule matches
+ * the launch logs' cap, so a long build cannot grow the config without
+ * bound.
+ */
+function persistGetLogs(output) {
+    if (output === '')
+        return;
+    const stored = readConfig();
+    const joined = `${stored.lastLogs}${stored.lastLogs === '' ? '' : '\n'}${output}`;
+    writeConfig(stored.engine, stored.config, stored.allowRunDeps, stored.platform, stored.showHelp, stored.providers, stored.logPath, joined.slice(-65536));
+}
 /**
  * resolveContextWindow picks the context window the registrar publishes: the
  * config's maxContext when it names one, else the native ceiling of the
@@ -894,13 +1216,16 @@ export async function unregisterFor(localInfer, request) {
     return { removed: true };
 }
 /**
- * registerLocalInferRoute registers the summary, save, deps, install, launch,
- * stop, register, and unregister routes on the web server and holds them by
- * an effect, so a bundle switch off removes them before the next switch on
- * re-registers. The scoped context carries the webServer; the localInfer
- * service is passed in because the scope only injects what it names.
+ * registerLocalInferRoute registers the summary, save, deps, install, get,
+ * launch, stop, register, and unregister routes on the web server and holds
+ * them by an effect, so a bundle switch off removes them before the next
+ * switch on re-registers. The scoped context carries the webServer; the
+ * localInfer service is passed in because the scope only injects what it
+ * names. The optional getHost is the lifecycle host the Get route's git and
+ * build steps run through; it defaults to the node host, and a test injects
+ * a stub so the route never clones a real repo in CI.
  */
-export function registerLocalInferRoute(scope, localInfer) {
+export function registerLocalInferRoute(scope, localInfer, getHost) {
     const summary = async (url) => {
         const engineParam = url.searchParams.get('engine');
         const configParam = url.searchParams.get('config');
@@ -990,23 +1315,33 @@ export function registerLocalInferRoute(scope, localInfer) {
                 // reads, so a provider never carries a field it cannot price. A save
                 // that updates an entry in place carries the entry's launch record
                 // over, so editing a running provider's config never drops the record
-                // the restart re-link prices.
+                // the restart re-link prices. A settings-only save skips the upsert:
+                // it persists the global fields the toggle edits and keeps the stored
+                // list intact, so the help and allow-run toggles never mint a
+                // duplicate entry.
                 const stored = readConfig();
-                const provider = {
-                    id: providerId ?? newProviderId(),
-                    engine,
-                    config,
-                    platform: platform[engine] ?? {},
-                };
-                if (providerId !== undefined) {
-                    const existing = stored.providers.find((entry) => entry.id === providerId);
-                    if (existing?.launch !== undefined) {
-                        provider.launch = existing.launch;
+                let providers;
+                if (body.settingsOnly === true) {
+                    providers = stored.providers;
+                }
+                else {
+                    const provider = {
+                        id: providerId ?? newProviderId(),
+                        engine,
+                        config,
+                        platform: platform[engine] ?? {},
+                    };
+                    if (providerId !== undefined) {
+                        const existing = stored.providers.find((entry) => entry.id === providerId);
+                        if (existing?.launch !== undefined) {
+                            provider.launch = existing.launch;
+                        }
                     }
+                    providers =
+                        providerId !== undefined
+                            ? stored.providers.map((entry) => (entry.id === providerId ? provider : entry))
+                            : [provider, ...stored.providers];
                 }
-                const providers = providerId !== undefined
-                    ? stored.providers.map((entry) => (entry.id === providerId ? provider : entry))
-                    : [provider, ...stored.providers];
                 writeConfig(engine, config, allowRunDeps, platform, showHelp, providers, logPath);
                 // Re-sync the service registry with the saved platform map, so the next
                 // launch reads the platform config the user just saved.
@@ -1265,6 +1600,68 @@ export function registerLocalInferRoute(scope, localInfer) {
             }
         },
     };
+    // The Get route: a POST whose answer streams as plain text, so the card
+    // appends the git sync, the dependency run, and the build output to its
+    // Logs section as it lands. The full run persists as the last-run logs.
+    const get = {
+        name: 'local-infer-get',
+        kind: 'exact',
+        path: '/local-infer/get',
+        handler: async (req, res) => {
+            const send = (status, body) => {
+                res.writeHead(status, { 'content-type': 'application/json' });
+                res.end(JSON.stringify(body));
+            };
+            if (req.method !== 'POST') {
+                res.writeHead(405).end();
+                return;
+            }
+            try {
+                const chunks = [];
+                let total = 0;
+                for await (const chunk of req) {
+                    total += chunk.length;
+                    if (total > 64 * 1024) {
+                        send(413, { error: 'get payload too large' });
+                        req.destroy();
+                        return;
+                    }
+                    chunks.push(chunk);
+                }
+                const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+                const request = {};
+                if (typeof body.engine === 'string') {
+                    request.engine = body.engine;
+                }
+                if (body.config && typeof body.config === 'object') {
+                    request.config = body.config;
+                }
+                const platform = parseStoredPlatformConfig(body.platform);
+                if (platform !== undefined) {
+                    request.platform = platform;
+                }
+                res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' });
+                let collected = '';
+                const log = (text) => {
+                    collected += text;
+                    if (typeof res.write === 'function') {
+                        res.write(text);
+                    }
+                };
+                try {
+                    await getEngine(localInfer, request, log, getHost);
+                }
+                catch (error) {
+                    log(`!! get failed: ${String(error?.message ?? error)}\n`);
+                }
+                persistGetLogs(collected);
+                res.end();
+            }
+            catch (error) {
+                send(400, { error: String(error?.message ?? error) });
+            }
+        },
+    };
     // The launch and stop routes share a POST body parser: the engine, config,
     // and platform override the plan renders from, falling back to the stored
     // config per key. The stop route ignores the platform key. `providerId`
@@ -1285,6 +1682,9 @@ export function registerLocalInferRoute(scope, localInfer) {
         if (typeof body.providerId === 'string' && body.providerId.trim() !== '') {
             request.providerId = body.providerId;
         }
+        if (typeof body.autoRebuild === 'boolean') {
+            request.autoRebuild = body.autoRebuild;
+        }
         return request;
     };
     const launch = {
@@ -1313,7 +1713,34 @@ export function registerLocalInferRoute(scope, localInfer) {
                     chunks.push(chunk);
                 }
                 const body = JSON.parse(Buffer.concat(chunks).toString('utf8'));
-                send(200, await launchEngine(localInfer, launchRequestFromBody(body)));
+                // The launch streams its progress as NDJSON: a step event as each phase
+                // (prereqs, download, build, launch) begins, then a final result event.
+                // The card's Launch control reads the step that is running and times
+                // out only the launch (health-poll) step; the rebuild steps run as long
+                // as they need to.
+                res.writeHead(200, { 'content-type': 'application/x-ndjson; charset=utf-8' });
+                const writeLine = (line) => {
+                    if (typeof res.write === 'function') {
+                        res.write(JSON.stringify(line) + '\n');
+                    }
+                };
+                const onProgress = (step) => {
+                    writeLine({ step });
+                };
+                try {
+                    const result = await launchEngine(localInfer, launchRequestFromBody(body), onProgress);
+                    writeLine({ result });
+                }
+                catch (error) {
+                    // A launch that breaks before a plan renders (an unknown engine, a
+                    // hardware probe failure) still settles the card's control to the red
+                    // Logs state through a result event, not a bare 500.
+                    const detail = error instanceof RouteError
+                        ? error.message
+                        : String(error?.message ?? error);
+                    writeLine({ result: { healthy: false, detail } });
+                }
+                res.end();
             }
             catch (error) {
                 if (error instanceof RouteError) {
@@ -1457,6 +1884,16 @@ export function registerLocalInferRoute(scope, localInfer) {
         // route registration, so a launch before the first save reads the
         // platform config the user last saved.
         syncPlatformConfigs(localInfer, readConfig());
+        // The engine death observer: a crash, a pkill, or the poll-detected exit
+        // of an adopted process clears the provider entry's launch record and
+        // notes the exit in the last-run logs the moment it happens, so the card
+        // and a later restart read the provider stopped rather than stale.
+        localInfer.setEngineDeathObserver(handleEngineDeath);
+        // The mount re-link: re-adopt a surviving engine from a stored launch
+        // record and start its liveness watcher without waiting for the card to
+        // open the summary route, so a DSH that restarts re-attaches its engines
+        // and a pkill after the restart still settles the stored state.
+        void relinkStoredProviders(localInfer, readConfig()).catch(() => undefined);
         const disposeSummary = scope.webServer.register(route);
         const disposeSave = scope.webServer.register(save);
         const disposeDeleteProvider = scope.webServer.register(deleteProvider);
@@ -1464,11 +1901,13 @@ export function registerLocalInferRoute(scope, localInfer) {
         const disposeInstall = scope.webServer.register(install);
         const disposeDownload = scope.webServer.register(download);
         const disposeChatTemplate = scope.webServer.register(chatTemplate);
+        const disposeGet = scope.webServer.register(get);
         const disposeLaunch = scope.webServer.register(launch);
         const disposeStop = scope.webServer.register(stop);
         const disposeRegister = scope.webServer.register(register);
         const disposeUnregister = scope.webServer.register(unregister);
         return () => {
+            localInfer.setEngineDeathObserver(undefined);
             disposeSummary();
             disposeSave();
             disposeDeleteProvider();
@@ -1476,6 +1915,7 @@ export function registerLocalInferRoute(scope, localInfer) {
             disposeInstall();
             disposeDownload();
             disposeChatTemplate();
+            disposeGet();
             disposeLaunch();
             disposeStop();
             disposeRegister();