dsh-plugin-local-infer 0.1.1 → 0.1.3

package/dsh/client.js

@@ -83,6 +83,8 @@ window.__ModuleLoader__.load({
         run: 'Run',
         running: 'running...',
         get: 'Get',
+        getting: 'Getting...',
+        getFailed: 'get failed',
         allowRun: 'Allow one-click install (sudo)',
         depsSatisfied: 'All dependencies satisfied.',
         installRejected: 'one-click install is not allowed; copy the install string instead',
@@ -94,6 +96,7 @@ window.__ModuleLoader__.load({
         unregistered: 'removed',
         unregisterFailed: 'remove failed',
         launch: 'Launch',
+        autoRebuild: 'Auto Rebuild',
         launching: 'Launching...',
         launchFailed: 'launch failed',
         runningOn: 'running on port',
@@ -106,6 +109,8 @@ window.__ModuleLoader__.load({
         enginePlatform: 'Engine platform',
         engineDirectory: 'Engine Directory',
         engineFork: 'Engine Fork (Git Repo)',
+        buildCommands: 'Build commands',
+        dockerTag: 'Docker tag',
         dirPlaceholder: 'directory path',
         forkPlaceholder: 'git repo url',
         hfCliDetected: 'HF CLI detected:',
@@ -115,6 +120,7 @@ window.__ModuleLoader__.load({
         downloaded: 'download complete',
         downloadFailed: 'download failed',
         helpToggle: 'Show or hide field help',
+        refresh: 'Re-fetch the card data from the host',
         engineHelp:
           'Inference engines have different strengths and weaknesses for specific models and hardware.',
         modelHelp:
@@ -123,8 +129,12 @@ window.__ModuleLoader__.load({
           'How the engine is deployed. local builds it from source on the host; docker pulls a prebuilt image. The dependency plan and hardware guidelines price the selected mode.',
         modelDirHelp: 'Where model files are downloaded and served from.',
         engineDirHelp:
-          'Local directory of the engine source. In local build mode the deploy step clones and builds the engine here.',
+          'Local directory of the engine source. Get clones or updates the git repo and builds the engine here; with no override it lands in the model directory under the engine name.',
         engineForkHelp: 'Git repo that overrides the engine default upstream for the clone step.',
+        buildCommandsHelp:
+          'Local build command that overrides the engine default for the checkout build. Shown only in local build mode.',
+        dockerTagHelp:
+          'Docker image tag the docker deploy pulls. Shown only in docker build mode.',
         providers: 'Providers',
         newProvider: 'New provider',
         edit: 'Edit',
@@ -139,9 +149,14 @@ window.__ModuleLoader__.load({
         registerNeedsSave: 'Save the Provider configuration before registering with DSH.',
         logs: 'Logs',
         logLocation: 'Log location',
+        resize: 'resize',
         entryLaunch: 'Launch',
         entryStop: 'Stop',
         entryLogs: 'Logs',
+        entryPrereqs: 'Prereqs...',
+        entryDownloading: 'Downloading...',
+        entryBuilding: 'Building...',
+        entryLaunching: 'Launching...',
         chatTemplatePreset: 'Chat template preset',
         customChatTemplate: 'Custom Chat template',
         custom: 'Custom',
@@ -210,6 +225,8 @@ window.__ModuleLoader__.load({
         run: '运行',
         running: '运行中…',
         get: '获取',
+        getting: '获取中…',
+        getFailed: '获取失败',
         allowRun: '允许一键安装 (sudo)',
         depsSatisfied: '所有依赖已满足。',
         installRejected: '未允许一键安装；请复制安装命令。',
@@ -221,6 +238,7 @@ window.__ModuleLoader__.load({
         unregistered: '已移除',
         unregisterFailed: '移除失败',
         launch: '启动',
+        autoRebuild: '自动重建',
         launching: '启动中…',
         launchFailed: '启动失败',
         runningOn: '运行于端口',
@@ -233,6 +251,8 @@ window.__ModuleLoader__.load({
         enginePlatform: '引擎平台',
         engineDirectory: '引擎目录',
         engineFork: '引擎 Fork (Git 仓库)',
+        buildCommands: '构建命令',
+        dockerTag: 'Docker 标签',
         dirPlaceholder: '目录路径',
         forkPlaceholder: 'git 仓库地址',
         hfCliDetected: '检测到 HF CLI:',
@@ -242,13 +262,16 @@ window.__ModuleLoader__.load({
         downloaded: '下载完成',
         downloadFailed: '下载失败',
         helpToggle: '显示或隐藏字段帮助',
+        refresh: '从主机重新加载卡片数据',
         engineHelp: '推理引擎针对特定模型和硬件各有优劣。',
         modelHelp: '引擎服务的模型。可选项包括引擎默认模型和模型目录中已有的模型文件。',
         buildHelp:
           '引擎的部署方式。local 在主机上从源码构建；docker 拉取预构建镜像。依赖计划和硬件准则按所选模式计价。',
         modelDirHelp: '模型文件的下载和服务目录。',
-        engineDirHelp: '引擎源码的本地目录。本地构建模式下，部署步骤在此克隆并构建引擎。',
+        engineDirHelp: '引擎源码的本地目录。“获取”会在此克隆或更新 git 仓库并构建引擎；未覆盖时，仓库落在模型目录下以引擎命名的子目录中。',
         engineForkHelp: '用于克隆步骤、覆盖引擎默认上游的 git 仓库。',
+        buildCommandsHelp: '本地构建命令，覆盖引擎默认的检查构建。仅在本地构建模式下显示。',
+        dockerTagHelp: 'docker 部署拉取的镜像标签。仅在 docker 构建模式下显示。',
         providers: '提供方',
         newProvider: '新增提供方',
         edit: '编辑',
@@ -262,9 +285,14 @@ window.__ModuleLoader__.load({
         registerNeedsSave: '注册到 DSH 之前请先保存该提供方配置。',
         logs: '日志',
         logLocation: '日志位置',
+        resize: '调整大小',
         entryLaunch: '启动',
         entryStop: '停止',
         entryLogs: '日志',
+        entryPrereqs: '前置条件…',
+        entryDownloading: '下载中…',
+        entryBuilding: '构建中…',
+        entryLaunching: '启动中…',
         chatTemplatePreset: '聊天模板预设',
         customChatTemplate: '自定义聊天模板',
         custom: '自定义',
@@ -432,6 +460,127 @@ window.__ModuleLoader__.load({
       color: '#fff',
       border: 'none',
     });
+
+    // The per-entry provider state machine: the card's Launch/Stop control
+    // lifecycle. The states are the button's reads: idle (a plain Launch), the
+    // four rebuild phases (prereqs, download, build, launch), running (a
+    // Stop), stopping (a disabled throbber while the stop is in flight), and
+    // failed (a red Logs). launchNextState is the hardened transition: a step
+    // event only advances forward through the rebuild phases (a stale or
+    // out-of-order step is a no-op), a healthy result settles to running, a
+    // failed result settles to failed, a stop moves a running (or idle, a
+    // provider running per the summary with no machine entry) engine to
+    // stopping, a confirmed stop settles to idle, a stop that is still running
+    // at the deadline settles to failed with the cause 'stop', and a break
+    // (the Logs control, a navigation away) resets: a launch failure reads as
+    // Launch (idle), a stop timeout reads as Stop (running), because the
+    // engine is probably still up. The machine takes the entry ({status,
+    // cause}) and returns the next entry, so the cause-aware reset stays in
+    // one place. An event that names no legal next state leaves the control
+    // where it is, so a late event never corrupts it.
+    var LAUNCH_STEP_ORDER = { prereqs: 0, download: 1, build: 2, launch: 3 };
+    var LAUNCH_PHASE_STATES = ['prereqs', 'download', 'build', 'launch'];
+    // The health-poll deadline: the route's poll runs up to two minutes, so a
+    // client-side deadline just past that cap forces a hung launch to the red
+    // Logs state. It arms only for the launch phase; the rebuild phases
+    // (prereqs, download, build) run as long as they need to, so a slow build
+    // never reads as a failure.
+    var LAUNCH_HEALTH_DEADLINE_MS = 150000;
+    // The stop-poll interval: while a stop is in flight, the card re-fetches
+    // the summary on this cadence so the provider's status dot repaints the
+    // moment the engine is down, instead of waiting out the host's 5-second
+    // process-watch and probe cycle.
+    var STOP_POLL_MS = 1000;
+    // The stop deadline: a provider still running 10 seconds after a Stop
+    // click settles to the red Logs state (the same path a failed launch
+    // takes), so the user can open the entry, fix the config, and retry.
+    var STOP_HEALTH_DEADLINE_MS = 10000;
+
+    function launchIsPhase(state) {
+      return LAUNCH_PHASE_STATES.indexOf(state) !== -1;
+    }
+
+    function launchNextState(entry, event) {
+      var current = entry && entry.status !== undefined ? entry.status : 'idle';
+      var cause = entry && entry.cause !== undefined ? entry.cause : undefined;
+      var type = event.type;
+      var next;
+      var nextCause;
+      if (type === 'start') {
+        // A launch begins from idle (a plain Launch), failed (a re-launch
+        // after the Logs control cleared the failed state), or downloading
+        // (a re-poll while the engine fetches its model files).
+        next =
+          current === 'idle' || current === 'failed' || current === 'downloading'
+            ? 'prereqs'
+            : current;
+        nextCause = undefined;
+      } else if (type === 'step') {
+        var target = event.step;
+        if (LAUNCH_STEP_ORDER[target] === undefined) {
+          next = current;
+          nextCause = cause;
+        } else if (current === 'idle' || current === 'failed') {
+          next = target;
+          nextCause = undefined;
+        } else if (current === 'running' || current === 'stopping') {
+          // A stop in flight supersedes a late launch step.
+          next = current;
+          nextCause = cause;
+        } else {
+          var currentOrder = LAUNCH_STEP_ORDER[current];
+          if (currentOrder === undefined) {
+            next = current;
+            nextCause = cause;
+          } else {
+            next = LAUNCH_STEP_ORDER[target] >= currentOrder ? target : current;
+            nextCause = undefined;
+          }
+        }
+      } else if (type === 'healthy') {
+        next = launchIsPhase(current) ? 'running' : current;
+        nextCause = undefined;
+      } else if (type === 'failed') {
+        next = launchIsPhase(current) ? 'failed' : current;
+        nextCause = undefined;
+      } else if (type === 'downloading') {
+        // The engine is fetching its model files: a busy throbber, not a
+        // failure. The card re-polls (a re-launch) until the engine reports
+        // ready, which settles the control to running.
+        next = launchIsPhase(current) ? 'downloading' : current;
+        nextCause = undefined;
+      } else if (type === 'stop') {
+        // A stop moves a running engine (or an idle one running per the
+        // summary, or a launch in flight) to the stopping state; a stop
+        // already in flight is a no-op.
+        next =
+          current === 'running' ||
+          current === 'stopping' ||
+          current === 'idle' ||
+          launchIsPhase(current)
+            ? 'stopping'
+            : current;
+        nextCause = undefined;
+      } else if (type === 'stopped') {
+        // The fast poll confirmed the provider is no longer running.
+        next = current === 'stopping' ? 'idle' : current;
+        nextCause = undefined;
+      } else if (type === 'stopFailed') {
+        // The deadline fired while the provider was still running.
+        next = current === 'stopping' ? 'failed' : current;
+        nextCause = current === 'stopping' ? 'stop' : cause;
+      } else if (type === 'reset') {
+        // A launch failure reads as Launch (idle); a stop timeout reads as
+        // Stop (running), because the engine is probably still up.
+        next = current === 'failed' ? (cause === 'stop' ? 'running' : 'idle') : 'idle';
+        nextCause = undefined;
+      } else {
+        next = current;
+        nextCause = cause;
+      }
+      return { status: next, cause: nextCause };
+    }
+
     // The deps panel. The install block is a copy/paste target, so it gets a
     // monospace pre with its own copy button; the dep rows read their status
     // from a state dot (the DSH StateDot, or its glyph fallback), not a word,
@@ -476,10 +625,10 @@ window.__ModuleLoader__.load({
       gap: 4,
       justifyContent: 'flex-end',
     };
-    // The circular "?" button in the card header. It toggles the per-field
-    // descriptions; the preference persists through the save route, so it
-    // survives a reload. The active state reads as the accent fill; the
-    // inactive state as the muted outline.
+    // The circular header buttons: the "?" help toggle and the refresh
+    // action. The active state reads as the accent fill; the inactive state
+    // as the muted outline. The help preference persists through the save
+    // route, so it survives a reload.
     var HELP_BUTTON_STYLE = (active) => ({
       width: 20,
       height: 20,
@@ -818,36 +967,60 @@ window.__ModuleLoader__.load({
     // a collapsed card with a status dot (green running, red stopped, yellow
     // The per-entry Launch control: a card entry's own lifecycle button, shown
     // alongside its Edit and Delete controls. Idle reads as a Launch button
-    // that starts the entry's engine; a launch in flight shows a disabled
-    // control with the spinner inside; a healthy engine reads as an enabled
-    // Stop; a launch that timed out reads as a red Logs control that opens the
-    // entry for editing, the same action as Edit.
+    // that starts the entry's engine; a rebuild in flight shows a disabled
+    // control with the spinner and the phase label (Prereqs, Downloading,
+    // Building, Launching); a healthy engine reads as an enabled Stop; a launch
+    // that timed out reads as a red Logs control that opens the entry for
+    // editing, the same action as Edit.
     function renderEntryLaunchButton(react, primitives, provider, opts) {
       var state = (opts.launchState || {})[provider.id];
-      if (state !== undefined && state.status === 'launching') {
-        return react.createElement(
-          'button',
-          {
-            type: 'button',
-            disabled: true,
-            style: Object.assign(
-              { display: 'inline-flex', alignItems: 'center', gap: 4, opacity: 0.7 },
-              GHOST_BUTTON,
-            ),
-            'aria-label': opts.launchingLabel,
-          },
-          renderThrobber(react, primitives),
-          react.createElement('span', null, opts.launchingLabel),
-        );
+      var status = state !== undefined ? state.status : 'idle';
+      // A rebuild phase in flight: a disabled control with the spinner and the
+      // phase label, so the button reads the step that is actually running.
+      var phaseLabels = {
+        prereqs: opts.prereqsLabel,
+        download: opts.downloadingLabel,
+        build: opts.buildingLabel,
+        launch: opts.launchingLabel,
+      };
+      var phaseLabel = phaseLabels[status];
+      if (phaseLabel !== undefined) {
+        return renderProcessButton(react, primitives, {
+          busy: true,
+          label: phaseLabel,
+          busyLabel: phaseLabel,
+          variant: 'ghost',
+          onClick: function () {},
+        });
+      }
+      // A stop in flight: a disabled control with the spinner and the
+      // stopping label, the same throbber the launch phases show.
+      if (status === 'stopping') {
+        return renderProcessButton(react, primitives, {
+          busy: true,
+          label: opts.stoppingLabel,
+          busyLabel: opts.stoppingLabel,
+          variant: 'ghost',
+          onClick: function () {},
+        });
+      }
+      // The engine is fetching its model files (the Strata download): a busy
+      // throbber that reads as in progress, not a failure. The card re-polls
+      // (a re-launch) until the engine reports ready.
+      if (status === 'downloading') {
+        return renderProcessButton(react, primitives, {
+          busy: true,
+          label: opts.downloadingLabel,
+          busyLabel: opts.downloadingLabel,
+          variant: 'ghost',
+          onClick: function () {},
+        });
       }
       // The Stop control reads from the provider status dot, not just the
       // per-entry launch state: the launch state is lost when the user
       // navigates away from the plugin page and back, so a running engine
       // (a green dot) must keep the control as Stop, not reset to Launch.
-      if (
-        (state !== undefined && state.status === 'running') ||
-        provider.status === 'running'
-      ) {
+      if (status === 'running' || provider.status === 'running') {
         return renderButton(
           react,
           primitives,
@@ -856,10 +1029,10 @@ window.__ModuleLoader__.load({
           opts.stopLabel,
         );
       }
-      if (state !== undefined && state.status === 'failed') {
-        // A launch that timed out: a red Logs control that opens the entry for
-        // editing and clears the failed state, so the control reads as Launch
-        // again and the user can fix the config and re-launch.
+      if (status === 'failed') {
+        // A launch that timed out or failed: a red Logs control that opens the
+        // entry for editing and clears the failed state, so the control reads
+        // as Launch again and the user can fix the config and re-launch.
         return react.createElement(
           'button',
           {
@@ -890,6 +1063,43 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // The owner/repo short name the provider title bar renders when an entry
+    // names a fork (the git repo that overrides the engine default upstream).
+    // It accepts a protocol URL (https://github.com/owner/repo), an scp-style
+    // git@host:owner/repo reference, and an already-short owner/repo form,
+    // stripping a trailing .git. It returns undefined when no repo name is
+    // present, so the title bar falls back to the engine label.
+    function repoShortName(ref) {
+      if (typeof ref !== 'string' || ref.trim() === '') {
+        return undefined;
+      }
+      var value = ref.trim();
+      var isUrl = /^[a-z][a-z0-9+.-]*:\/\//i.test(value);
+      if (isUrl) {
+        // Drop the scheme and the host segment, leaving owner/repo.
+        value = value.replace(/^[a-z][a-z0-9+.-]*:\/\//i, '').replace(/^[^/]+\//, '');
+      } else {
+        var colon = value.indexOf(':');
+        var slash = value.indexOf('/');
+        // An scp-style git@host:owner/repo reference: drop the host prefix.
+        if (colon !== -1 && (slash === -1 || colon < slash)) {
+          value = value.slice(colon + 1);
+        }
+      }
+      var segments = value.split('/').filter(function (part) {
+        return part !== '';
+      });
+      if (segments.length === 0) {
+        return undefined;
+      }
+      var repo = segments[segments.length - 1].replace(/\.git$/, '');
+      if (repo === '') {
+        return undefined;
+      }
+      var owner = segments.length > 1 ? segments[segments.length - 2] : undefined;
+      return owner ? owner + '/' + repo : repo;
+    }
+
     // unsure), an "Engine: Model" title, and Edit/Delete controls. A New
     // provider button resets the form to a fresh entry. The list sits above
     // the editing form, so a provider's full config form stays the single
@@ -906,6 +1116,15 @@ window.__ModuleLoader__.load({
           ((opts.engines || []).find(function (engine) {
             return engine.id === provider.engine;
           }) || {}).label || provider.engine;
+        // The title bar renders the fork's owner/repo when the entry names a
+        // fork, so a forked engine reads as its repo (Ninfer/ninfer-all)
+        // rather than the engine label (NInfer). No fork, or an unparseable
+        // one, keeps the engine label.
+        var forkName =
+          provider.platform && typeof provider.platform === 'object'
+            ? repoShortName(provider.platform.engineFork)
+            : undefined;
+        var titleLabel = forkName !== undefined ? forkName : engineLabel;
         var modelLabel =
           provider.model && provider.model !== '' ? provider.model : opts.modelAuto;
         return react.createElement(
@@ -934,21 +1153,21 @@ window.__ModuleLoader__.load({
                 whiteSpace: 'nowrap',
               },
               title:
-                engineLabel +
+                titleLabel +
                 ': ' +
                 modelLabel +
                 ' (' +
                 (statusToLabel[provider.status] || provider.status) +
                 ')',
               'aria-label':
-                engineLabel +
+                titleLabel +
                 ': ' +
                 modelLabel +
                 ' (' +
                 (statusToLabel[provider.status] || provider.status) +
                 ')',
             },
-            engineLabel +
+            titleLabel +
               ': ' +
               modelLabel +
               ' (' +
@@ -1039,6 +1258,39 @@ window.__ModuleLoader__.load({
       });
     }
 
+    // The reusable stateful process button: the Disable/Throbber/Reset
+    // lifecycle every process control (Get, Launch, Stop, Run, Download)
+    // shares. While the process is in flight (busy) it reads as a disabled
+    // control with the spinner and the in-progress label; when it settles the
+    // caller flips busy back to false and the control resets to the idle
+    // action button (the label and the click handler). A host without the
+    // primitives seed keeps the native fallback through renderButton.
+    function renderProcessButton(react, primitives, opts) {
+      if (opts.busy === true) {
+        return react.createElement(
+          'button',
+          {
+            type: 'button',
+            disabled: true,
+            style: Object.assign(
+              { display: 'inline-flex', alignItems: 'center', gap: 4, opacity: 0.7 },
+              GHOST_BUTTON,
+            ),
+            'aria-label': opts.busyLabel,
+          },
+          renderThrobber(react, primitives),
+          react.createElement('span', null, opts.busyLabel),
+        );
+      }
+      return renderButton(
+        react,
+        primitives,
+        opts.variant,
+        { onClick: opts.onClick, disabled: opts.disabled === true },
+        opts.label,
+      );
+    }
+
     // The chat-template control, split from the old finicky free-text combo
     // into a preset dropdown (the shipped presets plus a "Custom" entry) and a
     // "Custom Chat template" text field that shows while the preset is
@@ -1568,6 +1820,11 @@ window.__ModuleLoader__.load({
       );
     }
 
+    // The Get run's output-idle cap. Two minutes without a streamed line
+    // reads as a stalled build: the card re-enables Launch while the run
+    // keeps streaming in the background.
+    var GET_IDLE_MS = 120000;
+
     // The "System dependencies" panel: the per-dep status list, the copy/paste
     // install block, the Play/Run arrow (only while the trust gate is on),
     // and the "Get" gate that stays disabled until every dep reports
@@ -1684,21 +1941,22 @@ window.__ModuleLoader__.load({
             label: t.allowRun,
           }),
           deps.runAllowed && !deps.allSatisfied
-            ? renderButton(
-                react,
-                primitives,
-                'ghost',
-                { onClick: actions.onRun, disabled: actions.installing },
-                actions.installing ? t.running : '▶ ' + t.run,
-              )
+            ? renderProcessButton(react, primitives, {
+                busy: actions.installing === true,
+                label: '▶ ' + t.run,
+                busyLabel: t.running,
+                variant: 'ghost',
+                onClick: actions.onRun,
+              })
             : null,
-          renderButton(
-            react,
-            primitives,
-            'primary',
-            { onClick: actions.onGet, disabled: !deps.allSatisfied },
-            t.get,
-          ),
+          renderProcessButton(react, primitives, {
+            busy: actions.getting === true,
+            label: t.get,
+            busyLabel: t.getting,
+            variant: 'primary',
+            onClick: actions.onGet,
+            disabled: !deps.allSatisfied,
+          }),
         ),
         actions.depsNote
           ? react.createElement(
@@ -1766,12 +2024,26 @@ window.__ModuleLoader__.load({
         // does.
         var launchingState = react.useState(false);
         var stoppingState = react.useState(false);
+        // The Get step's state. Get runs the git sync, the dependency plan,
+        // and the engine build on the host through /local-infer/get, and the
+        // streamed output lands in getLogs (the Logs section shows it while
+        // the run is in flight). Launch stays disabled while a Get is in
+        // flight; the idle timer re-enables it once GET_IDLE_MS passes with
+        // no output, so a silent build never parks the button.
+        var gettingState = react.useState(false);
+        var getLogsState = react.useState(null);
+        var getIdleTimerRef = react.useRef(null);
         // Whether the draft's engine is confirmed running, so the single
         // Launch/Stop control reads as Stop while the engine is up and Launch
         // while it is down, the same toggle the per-entry control does. A
         // healthy launch sets it, a stop clears it.
         var draftRunningState = react.useState(false);
         var lifecycleNoteState = react.useState('');
+        // The Auto Rebuild checkbox next to the form's Launch button. Checked
+        // by default: a launch runs the git sync (fetch, rebase, rebuild)
+        // before spawning the engine. Unchecked, the launch skips the sync and
+        // starts the checkout as-is.
+        var autoRebuildState = react.useState(true);
         // The model download state. The Download button runs the hf CLI
         // download through the /local-infer/download route, and the note
         // reports the answer the route returned.
@@ -1815,11 +2087,39 @@ window.__ModuleLoader__.load({
         // The log-file location the card's log-location field edits. Seeded
         // from the summary's stored template on load; a Save persists it.
         var logPathState = react.useState('');
+        // The Logs section's textarea height in px, resized by the diagonal
+        // chevron drag handle in the section's bottom-right corner.
+        var logsHeightState = react.useState(96);
+        // The Logs section's auto-scroll mode. 'fresh' is the pane just
+        // opened: the first content render scrolls to the bottom and arms
+        // 'scrolling'. 'scrolling' pins the view to the bottom on content
+        // updates. 'manual' means the user scrolled up, so content updates
+        // leave the view where the user put it. A scroll to the very bottom
+        // re-arms 'scrolling'.
+        var logsScrollModeState = react.useState('fresh');
+        // The Logs textarea element, so the auto-scroll effect and the scroll
+        // handler read the live scroll metrics.
+        var logsTextareaRef = react.useRef(null);
+        // The in-flight chevron drag: the pointer's starting Y and the height
+        // it started from, so a move computes the new height from a stable
+        // base instead of a stale render closure.
+        var logsDragRef = react.useRef(null);
         // The per-entry launch state: a map from provider id to the entry's
-        // lifecycle ('launching', 'running', 'failed') and the start time a
-        // launch began, so a card entry can show its spinner, Stop, or red
+        // launch-state-machine state (the rebuild phases 'prereqs', 'download',
+        // 'build', 'launch', plus 'running' and 'failed') and the start time a
+        // launch began, so a card entry can show its phase label, Stop, or red
         // Logs control. Absent entries read as idle (a plain Launch button).
         var entryLaunchState = react.useState({});
+        // The provider statuses the summary last painted, mirrored into a ref
+        // so the stop fast-poll reads the value the last fetch settled, not a
+        // stale closure.
+        var providerStatusRef = react.useRef({});
+        // The latest fetchSummary, mirrored into a ref so the stop fast-poll
+        // re-fetches through the current callback, not a stale one.
+        var fetchSummaryRef = react.useRef(null);
+        // The stop fast-poll and deadline timers (per-entry), plus the
+        // draft-based stop's poll timer, so an unmount clears them all.
+        var stopTimersRef = react.useRef({ poll: null, deadline: null, draftPoll: null });
         var data = dataState[0];
         var draft = draftState[0];
         var note = noteState[0];
@@ -1834,8 +2134,11 @@ window.__ModuleLoader__.load({
         var agentDefault = agentDefaultState[0];
         var launching = launchingState[0];
         var stopping = stoppingState[0];
+        var getting = gettingState[0];
+        var getLogs = getLogsState[0];
         var draftRunning = draftRunningState[0];
         var lifecycleNote = lifecycleNoteState[0];
+        var autoRebuild = autoRebuildState[0];
         var downloading = downloadingState[0];
         var downloadNote = downloadNoteState[0];
         var templateDownloading = templateDownloadingState[0];
@@ -1847,7 +2150,36 @@ window.__ModuleLoader__.load({
         var providerFormMode = providerFormModeState[0];
         var cachedDraft = cachedDraftState[0];
         var logPath = logPathState[0];
+        var logsHeight = logsHeightState[0];
+        var logsScrollMode = logsScrollModeState[0];
+        // The Logs section's displayed text: the streamed Get buffer while a
+        // run is in flight, else the persisted last-run logs the summary
+        // carries. One value the auto-scroll effect and the textarea share.
+        var displayedLogs =
+          getLogs !== null ? getLogs : data !== null && data.lastLogs ? data.lastLogs : '';
         var entryLaunch = entryLaunchState[0];
+        // The title-bar Launch/Stop control mirrors the edited provider's
+        // per-entry launch state, so the entry's Launch button and the form's
+        // control read the same lifecycle (a phase throbber, a Stop when
+        // healthy, a red Logs on a failed launch).
+        var editedProvider =
+          editingProviderId !== null
+            ? (data.providers || []).find((provider) => provider.id === editingProviderId)
+            : undefined;
+        var mirroredStatus =
+          editedProvider !== undefined ? (entryLaunch[editedProvider.id] || {}).status : undefined;
+        var mirroredPhaseLabel =
+          {
+            prereqs: t.entryPrereqs,
+            download: t.entryDownloading,
+            build: t.entryBuilding,
+            launch: t.entryLaunching,
+            // The engine model fetch (the Strata download): the same throbber
+            // label the download phase shows, so the title bar mirrors the
+            // entry's Launch button while the engine fetches its files.
+            downloading: t.entryDownloading,
+            stopping: t.stopping,
+          }[mirroredStatus];
         // The no-entries case forces the form into new-provider mode on
         // render: with nothing stored, the form is where the first provider
         // is entered, and the "New provider" control reads as plain text.
@@ -1856,6 +2188,77 @@ window.__ModuleLoader__.load({
             ? 'new'
             : providerFormMode;
         var timerRef = react.useRef(null);
+        // The latest committed draft, mirrored into a ref so the debounced
+        // re-price reads the value the user last typed, not a stale closure.
+        // The effect runs after each render, so the ref settles before the
+        // 300ms timer fires.
+        var draftRef = react.useRef(null);
+        react.useEffect(() => {
+          draftRef.current = draft;
+        }, [draft]);
+
+        // The Logs auto-scroll: while the mode is 'fresh' (the pane just
+        // opened) or 'scrolling', a content update pins the view to the
+        // bottom. The first render scrolls and arms 'scrolling'; a manual
+        // scroll up parks the mode at 'manual', so later updates leave the
+        // view where the user put it.
+        react.useEffect(() => {
+          var el = logsTextareaRef.current;
+          if (el === null) {
+            return;
+          }
+          if (logsScrollMode === 'fresh' || logsScrollMode === 'scrolling') {
+            el.scrollTop = el.scrollHeight;
+            if (logsScrollMode === 'fresh') {
+              logsScrollModeState[1]('scrolling');
+            }
+          }
+        }, [displayedLogs, logsScrollMode]);
+
+        // The Logs scroll handler: a scroll to the very bottom re-arms
+        // auto-scroll ('scrolling'); any other position parks the mode at
+        // 'manual', so content updates stop pinning the view. The 4px
+        // tolerance absorbs sub-pixel rounding at the end of the range.
+        var onLogsScroll = react.useCallback(() => {
+          var el = logsTextareaRef.current;
+          if (el === null) {
+            return;
+          }
+          var atBottom = el.scrollTop + el.clientHeight >= el.scrollHeight - 4;
+          logsScrollModeState[1](atBottom ? 'scrolling' : 'manual');
+        }, []);
+
+        // The Logs resize handle: a pointerdown on the chevron starts a
+        // vertical drag. A move computes the new height from the stable
+        // starting base (drag up shrinks the section to the default height,
+        // drag down expands it), clamped to a readable range. The window
+        // listeners read the drag base from the ref, so a re-render mid-drag
+        // never resets it.
+        var onLogsResizeStart = react.useCallback(
+          (event) => {
+            event.preventDefault();
+            logsDragRef.current = { startClientY: event.clientY, startHeight: logsHeight };
+            var onMove = (moveEvent) => {
+              var drag = logsDragRef.current;
+              if (drag === null) {
+                return;
+              }
+              moveEvent.preventDefault();
+              // Drag down (clientY grows) expands, drag up shrinks to the
+              // default height, so the delta is the pointer's downward travel.
+              var delta = moveEvent.clientY - drag.startClientY;
+              logsHeightState[1](Math.max(96, Math.min(480, drag.startHeight + delta)));
+            };
+            var onUp = () => {
+              logsDragRef.current = null;
+              window.removeEventListener('pointermove', onMove);
+              window.removeEventListener('pointerup', onUp);
+            };
+            window.addEventListener('pointermove', onMove);
+            window.addEventListener('pointerup', onUp);
+          },
+          [logsHeight],
+        );
 
         var fetchSummary = react.useCallback(
           (engine, config) => {
@@ -1874,6 +2277,17 @@ window.__ModuleLoader__.load({
               )
               .then((next) => {
                 dataState[1](next);
+                // Mirror the provider statuses the summary painted, so the
+                // stop fast-poll reads the latest dot values.
+                var statuses = {};
+                (next.providers || []).forEach(function (provider) {
+                  statuses[provider.id] = provider.status;
+                });
+                providerStatusRef.current = statuses;
+                // The streamed Get buffer yields to the persisted last-run
+                // logs the summary now carries, so the Logs section keeps
+                // the run's tail without a second copy.
+                getLogsState[1](null);
                 draftState[1]((current) => {
                   // The summary's platformConfigs is the host-persisted
                   // platform state, while the draft's platform entries are
@@ -1914,6 +2328,31 @@ window.__ModuleLoader__.load({
           [t],
         );
 
+        // Mirror the latest fetchSummary into a ref, so the stop fast-poll
+        // re-fetches through the current callback (its deps change with the
+        // locale), not a stale closure.
+        react.useEffect(() => {
+          fetchSummaryRef.current = fetchSummary;
+        }, [fetchSummary]);
+
+        // Clear the stop fast-poll and deadline timers on unmount, so a
+        // settled or abandoned stop never keeps re-fetching the summary.
+        react.useEffect(
+          () => () => {
+            var timers = stopTimersRef.current;
+            if (timers.poll !== null) {
+              clearTimeout(timers.poll);
+            }
+            if (timers.deadline !== null) {
+              clearTimeout(timers.deadline);
+            }
+            if (timers.draftPoll !== null) {
+              clearInterval(timers.draftPoll);
+            }
+          },
+          [],
+        );
+
         // The deps panel reads its own route, because it re-probes the host
         // on every fetch (the "Get" gate must read the live checkDeps
         // answer), while the summary re-prices the meter. Both ride the same
@@ -1945,6 +2384,25 @@ window.__ModuleLoader__.load({
           [],
         );
 
+        // scheduleReprice resets the re-price timeout on every field change
+        // and fetches the summary (the VRAM Est. meter) and the deps panel
+        // only after typing pauses, so a fast keystroke stream is one round
+        // trip, not one per letter. The ref reads the latest committed draft,
+        // so the fetch prices the value the user last typed.
+        var scheduleReprice = react.useCallback(() => {
+          if (timerRef.current) {
+            clearTimeout(timerRef.current);
+          }
+          timerRef.current = setTimeout(() => {
+            var latest = draftRef.current;
+            if (latest === null || latest === undefined) {
+              return;
+            }
+            fetchSummary(latest.engine, latest.config);
+            fetchDeps(latest.engine, latest.config);
+          }, 300);
+        }, [fetchSummary, fetchDeps]);
+
         var load = react.useCallback(() => {
           fetchSummary(null, null);
           fetchDeps(null, null);
@@ -1956,9 +2414,11 @@ window.__ModuleLoader__.load({
           }
         }, [data, draft, load]);
 
-        // A field edit updates the draft config and re-prices the meter and
-        // form gating. Debounced so a slider drag is one round trip, not one
-        // per tick.
+        // A field edit updates the draft config and schedules a debounced
+        // re-price of the meter and form gating. The draft update is pure;
+        // the re-price (the VRAM Est. visualization) runs only after typing
+        // pauses, so a fast keystroke stream is one round trip, not one per
+        // letter.
         var onValue = react.useCallback(
           (key, value) => {
             noteState[1]('');
@@ -1968,22 +2428,15 @@ window.__ModuleLoader__.load({
             draftState[1]((current) => {
               var config = Object.assign({}, current.config);
               config[key] = value;
-              var next = {
+              return {
                 engine: current.engine,
                 config: config,
                 platform: current.platform || {},
               };
-              if (timerRef.current) {
-                clearTimeout(timerRef.current);
-              }
-              timerRef.current = setTimeout(() => {
-                fetchSummary(next.engine, next.config);
-                fetchDeps(next.engine, next.config);
-              }, 300);
-              return next;
             });
+            scheduleReprice();
           },
-          [fetchSummary, fetchDeps],
+          [scheduleReprice],
         );
 
         // The Model Directory field edit. A valid directory (non-blank, no
@@ -2023,6 +2476,9 @@ window.__ModuleLoader__.load({
             }
             downloadingState[1](true);
             downloadNoteState[1]('');
+            // The click writes the "Downloading..." separator, so the run reads
+            // as a fresh Logs section that the download appends to.
+            startProcessLog(t.downloading);
             fetch('/local-infer/download', {
               method: 'POST',
               headers: { 'content-type': 'application/json' },
@@ -2054,7 +2510,7 @@ window.__ModuleLoader__.load({
                 downloadingState[1](false);
               });
           },
-          [draft, downloading, t, fetchSummary],
+          [draft, downloading, t, fetchSummary, startProcessLog],
         );
 
         // The chat-template download: pulls the selected template (the
@@ -2141,7 +2597,9 @@ window.__ModuleLoader__.load({
         // The help toggle: flip the local state and persist the preference
         // through the save route, so it survives a reload. The save response
         // carries the fresh summary, so the data and the draft resync from
-        // the same round trip, the way the allow-run toggle does.
+        // the same round trip, the way the allow-run toggle does. The
+        // settings-only flag keeps the route from upserting a provider entry,
+        // so a toggle never mints a duplicate at the top of the list.
         var onToggleHelp = react.useCallback(
           (next) => {
             if (draft === null) {
@@ -2157,6 +2615,7 @@ window.__ModuleLoader__.load({
                 allowRunDeps: deps !== null && deps.runAllowed === true,
                 platform: draft.platform || {},
                 showHelp: next,
+                settingsOnly: true,
               }),
             })
               .then((response) =>
@@ -2265,18 +2724,11 @@ window.__ModuleLoader__.load({
             draftState[1]((_current) => {
               // The platform config is per-engine, so an engine switch keeps
               // the map and only resets the per-engine parameter config.
-              var next = { engine: engine, config: {}, platform: _current.platform || {} };
-              if (timerRef.current) {
-                clearTimeout(timerRef.current);
-              }
-              timerRef.current = setTimeout(() => {
-                fetchSummary(next.engine, next.config);
-                fetchDeps(next.engine, next.config);
-              }, 300);
-              return next;
+              return { engine: engine, config: {}, platform: _current.platform || {} };
             });
+            scheduleReprice();
           },
-          [fetchSummary, fetchDeps],
+          [scheduleReprice],
         );
 
         var save = react.useCallback(() => {
@@ -2492,6 +2944,9 @@ window.__ModuleLoader__.load({
           }
         }, [deps, t]);
 
+        // The allow-run toggle persists the trust gate through the save route.
+        // The settings-only flag keeps the route from upserting a provider
+        // entry, so a toggle never mints a duplicate at the top of the list.
         var onAllowRun = react.useCallback(
           (checked) => {
             if (draft === null) {
@@ -2506,6 +2961,7 @@ window.__ModuleLoader__.load({
                 allowRunDeps: checked,
                 platform: draft.platform || {},
                 showHelp: help,
+                settingsOnly: true,
               }),
             })
               .then((response) =>
@@ -2571,15 +3027,97 @@ window.__ModuleLoader__.load({
             });
         }, [deps, draft, installing, t]);
 
+        // The Logs-section separator a provider process button writes when
+        // clicked: it appends a "--- {{label}}" line to the live Logs buffer
+        // (seeding from the persisted last-run logs when no run is in flight),
+        // so the new process reads as a fresh section that will append its
+        // commands and output to the buffer and the log file. The host route
+        // persists the same separator, so it survives a reload.
+        var startProcessLog = react.useCallback(
+          (label) => {
+            getLogsState[1]((current) => {
+              var base =
+                current !== null ? current : (data !== null && data.lastLogs ? data.lastLogs : '');
+              return base + (base === '' ? '' : '\n') + '--- ' + label + '\n';
+            });
+          },
+          [data],
+        );
+
         var onGet = react.useCallback(() => {
-          if (deps === null || draft === null) {
+          if (deps === null || draft === null || getting) {
             return;
           }
-          // "Get" is the gate: it re-checks the live dep state, so the button
-          // opens only after a re-check passes.
-          fetchDeps(draft.engine, draft.config);
-          depsNoteState[1](t.depsSatisfied);
-        }, [deps, draft, t, fetchDeps]);
+          // "Get" runs the git sync, the dependency plan, and the build on
+          // the host through /local-infer/get. The route streams its output;
+          // each chunk appends to the Logs section and re-arms the idle
+          // timer, and Launch stays disabled until the run finishes, fails,
+          // or falls silent for GET_IDLE_MS. The click writes the "Getting..."
+          // separator, so the run reads as a fresh Logs section.
+          gettingState[1](true);
+          depsNoteState[1]('');
+          startProcessLog(t.getting);
+          var append = (text) => {
+            getLogsState[1]((current) => (current === null ? '' : current) + text);
+          };
+          var armIdle = () => {
+            if (getIdleTimerRef.current) {
+              clearTimeout(getIdleTimerRef.current);
+            }
+            // Two minutes without a line reads as a stalled build: release
+            // Launch while the run keeps streaming in the background.
+            getIdleTimerRef.current = setTimeout(() => {
+              gettingState[1](false);
+            }, GET_IDLE_MS);
+          };
+          armIdle();
+          var platform = (draft.platform || {})[draft.engine];
+          fetch('/local-infer/get', {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({
+              engine: draft.engine,
+              config: draft.config,
+              platform: platform,
+            }),
+          })
+            .then((response) => {
+              if (!response.ok) {
+                return response.text().then((text) => {
+                  throw new Error(text || 'HTTP ' + response.status);
+                });
+              }
+              if (!response.body || typeof response.body.getReader !== 'function') {
+                // A host whose response cannot stream: read the whole body.
+                return response.text().then((text) => append(text));
+              }
+              var reader = response.body.getReader();
+              var decoder = new TextDecoder();
+              var pump = () =>
+                reader.read().then(({ done, value }) => {
+                  if (done) {
+                    return undefined;
+                  }
+                  append(decoder.decode(value, { stream: true }));
+                  armIdle();
+                  return pump();
+                });
+              return pump();
+            })
+            .catch((error) => {
+              append('\n' + t.getFailed + ': ' + (error && error.message ? error.message : '') + '\n');
+            })
+            .then(() => {
+              if (getIdleTimerRef.current) {
+                clearTimeout(getIdleTimerRef.current);
+                getIdleTimerRef.current = null;
+              }
+              gettingState[1](false);
+              // The route persisted the run as the last logs; the summary
+              // re-read hands the Logs section back to the stored value.
+              fetchSummary(draft.engine, draft.config);
+            });
+        }, [deps, draft, getting, data, t, fetchSummary, startProcessLog]);
 
         var onRegister = react.useCallback(() => {
           if (draft === null || registering) {
@@ -2678,6 +3216,10 @@ window.__ModuleLoader__.load({
             engine: draft.engine,
             config: draft.config,
             platform: platform,
+            // The Auto Rebuild checkbox: false skips the git sync (fetch,
+            // rebase, rebuild) and launches the checkout as-is. The stop
+            // route ignores the key.
+            autoRebuild: autoRebuild,
           };
           // The provider entry the draft edits: the route persists the launch
           // record (and the stop's clear) on that entry, so a restart re-links
@@ -2694,14 +3236,56 @@ window.__ModuleLoader__.load({
           }
           launchingState[1](true);
           lifecycleNoteState[1]('');
+          // The click writes the "Launching..." separator, so the run reads as
+          // a fresh Logs section that the launch appends to.
+          startProcessLog(t.launching);
           fetch('/local-infer/launch', {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
             body: launchBody(),
           })
-            .then((response) => response.json().then((body) => ({ ok: response.ok, body: body })))
-            .then(({ ok, body }) => {
-              if (ok) {
+            // The launch route streams NDJSON (a step event per phase, then a
+            // final result event). The main form's control does not show the
+            // phase labels, so read the stream and keep only the result event.
+            .then(function (response) {
+              if (response.body === null || typeof response.body.getReader !== 'function') {
+                return response.json().then(function (body) {
+                  return { ok: response.ok, result: body };
+                });
+              }
+              var reader = response.body.getReader();
+              var decoder = new TextDecoder();
+              var buffer = '';
+              var resultEvent = null;
+              function pump() {
+                return reader.read().then(function (chunk) {
+                  if (chunk.done) {
+                    return { ok: response.ok, result: resultEvent };
+                  }
+                  buffer += decoder.decode(chunk.value, { stream: true });
+                  var lines = buffer.split('\n');
+                  buffer = lines.pop();
+                  for (var i = 0; i < lines.length; i++) {
+                    if (lines[i] === '') {
+                      continue;
+                    }
+                    var event;
+                    try {
+                      event = JSON.parse(lines[i]);
+                    } catch {
+                      continue;
+                    }
+                    if (event.result !== undefined) {
+                      resultEvent = event.result;
+                    }
+                  }
+                  return pump();
+                });
+              }
+              return pump();
+            })
+            .then(({ ok, result: body }) => {
+              if (ok && body !== null) {
                 if (body.healthy) {
                   lifecycleNoteState[1](
                     t.runningOn + ' ' + (body.plan && body.plan.port ? body.plan.port : ''),
@@ -2713,7 +3297,9 @@ window.__ModuleLoader__.load({
                   lifecycleNoteState[1](t.notHealthy + (body.detail ? ': ' + body.detail : ''));
                 }
               } else {
-                lifecycleNoteState[1](t.launchFailed + (body.error ? ': ' + body.error : ''));
+                lifecycleNoteState[1](
+                  t.launchFailed + (body && body.detail ? ': ' + body.detail : ''),
+                );
               }
             })
             .catch((error) => {
@@ -2723,8 +3309,13 @@ window.__ModuleLoader__.load({
             })
             .then(() => {
               launchingState[1](false);
+              // The route persisted the run's launch command line and engine
+              // output as the last logs; the summary re-read hands the Logs
+              // section the new run, the same rule the per-entry launch and
+              // the Get apply when their run ends.
+              fetchSummary(draft.engine, draft.config);
             });
-        }, [draft, launching, editingProviderId, t]);
+        }, [draft, launching, editingProviderId, autoRebuild, t, fetchSummary, startProcessLog]);
 
         var onStop = react.useCallback(() => {
           if (draft === null || stopping) {
@@ -2732,6 +3323,15 @@ window.__ModuleLoader__.load({
           }
           stoppingState[1](true);
           lifecycleNoteState[1]('');
+          // Re-fetch the summary on a fast cadence for the duration of the
+          // stop action, so the provider's status dot repaints the moment the
+          // engine is down, instead of waiting out the host's 5-second
+          // process-watch cycle.
+          if (stopTimersRef.current.draftPoll === null) {
+            stopTimersRef.current.draftPoll = setInterval(function () {
+              fetchSummaryRef.current(null, null);
+            }, STOP_POLL_MS);
+          }
           fetch('/local-infer/stop', {
             method: 'POST',
             headers: { 'content-type': 'application/json' },
@@ -2755,43 +3355,79 @@ window.__ModuleLoader__.load({
             })
             .then(() => {
               stoppingState[1](false);
+              if (stopTimersRef.current.draftPoll !== null) {
+                clearInterval(stopTimersRef.current.draftPoll);
+                stopTimersRef.current.draftPoll = null;
+              }
             });
         }, [draft, stopping, editingProviderId, t]);
 
+        // Move one entry through the provider state machine, reading the
+        // current entry from the latest map so a late event prices the state it
+        // lands on, not a stale one. The per-entry launch and stop both drive
+        // the same machine through this one helper, so a transition is never
+        // priced twice.
+        var moveEntry = react.useCallback((providerId, event) => {
+          entryLaunchState[1]((current) => {
+            var entry = current[providerId] || { status: 'idle' };
+            var next = launchNextState(entry, event);
+            return Object.assign({}, current, {
+              [providerId]: Object.assign({}, next, { startTime: Date.now() }),
+            });
+          });
+        }, []);
+
         // The per-entry launch: a card entry's own Launch control drives its
-        // own engine, not the form's draft. It records a start time and the
-        // 'launching' state (the spinner), then reads the launch result's
-        // healthy flag: a 200 before the route's health-poll timeout reads as
-        // 'running' (the control becomes Stop), a timeout reads as 'failed'
-        // (the control becomes a red Logs that opens the entry for editing).
+        // own engine, not the form's draft. It starts the launch state machine
+        // at the prereqs phase, then reads the launch stream (an NDJSON step
+        // event as each phase begins, then a final result event) and drives the
+        // machine: each step event advances the phase label (Prereqs,
+        // Downloading, Building, Launching), a healthy result settles to
+        // running (the control becomes Stop), and a failed result or the
+        // health-poll deadline settles to failed (the control becomes a red
+        // Logs that opens the entry for editing).
         var onLaunchEntry = react.useCallback(
           (provider) => {
-            var state = entryLaunch[provider.id];
-            if (state !== undefined && state.status === 'launching') {
+            var prior = entryLaunch[provider.id];
+            var status = prior !== undefined ? prior.status : 'idle';
+            // A launch in flight (a rebuild phase) or a stop in flight is
+            // ignored; a running engine is stopped by its own Stop control,
+            // not re-launched.
+            if (status !== 'idle' && status !== 'failed') {
               return;
             }
-            entryLaunchState[1]((current) =>
-              Object.assign({}, current, {
-                [provider.id]: { status: 'launching', startTime: Date.now() },
-              }),
-            );
-            // The route's health-poll can run up to two minutes, and a build
-            // step before it can run longer still, so a slow or hung route
-            // would leave the control on the spinner forever. A client-side
-            // deadline just past the route's cap forces the control to the red
-            // Logs state so the entry can be opened and fixed.
+            moveEntry(provider.id, { type: 'start' });
+            // The click writes the "Launching..." separator, so the entry's run
+            // reads as a fresh Logs section that the launch appends to.
+            startProcessLog(t.entryLaunching);
+            var move = function (event) {
+              moveEntry(provider.id, event);
+            };
+            // The health-poll deadline: the route's poll runs up to two minutes,
+            // so a client-side deadline just past that cap forces a hung launch
+            // to the red Logs state. It arms only for the launch phase; the
+            // rebuild phases (prereqs, download, build) run as long as they
+            // need to, so a slow build never reads as a failure.
             var settled = false;
-            var deadline = setTimeout(function () {
-              if (settled) {
+            var deadline = null;
+            var armDeadline = function () {
+              if (deadline !== null) {
                 return;
               }
-              settled = true;
-              entryLaunchState[1]((current) =>
-                Object.assign({}, current, {
-                  [provider.id]: { status: 'failed', startTime: Date.now() },
-                }),
-              );
-            }, 150000);
+              deadline = setTimeout(function () {
+                if (settled) {
+                  return;
+                }
+                settled = true;
+                move({ type: 'failed' });
+              }, LAUNCH_HEALTH_DEADLINE_MS);
+            };
+            var clearDeadline = function () {
+              if (deadline !== null) {
+                clearTimeout(deadline);
+                deadline = null;
+              }
+            };
             fetch('/local-infer/launch', {
               method: 'POST',
               headers: { 'content-type': 'application/json' },
@@ -2804,36 +3440,157 @@ window.__ModuleLoader__.load({
                 providerId: provider.id,
               }),
             })
-              .then((response) => response.json().then((body) => ({ ok: response.ok, body: body })))
-              .then(({ ok, body }) => {
-                settled = true;
-                clearTimeout(deadline);
-                var nextStatus = ok && body.healthy ? 'running' : 'failed';
-                entryLaunchState[1]((current) =>
-                  Object.assign({}, current, {
-                    [provider.id]: { status: nextStatus, startTime: Date.now() },
-                  }),
-                );
-                // The provider status dots price the process probe on a
-                // summary fetch, so a launch that turned an engine healthy
-                // re-fetches the summary to repaint the dot from red to green.
-                fetchSummary(provider.engine, provider.config || {});
+              .then(function (response) {
+                // The launch streams NDJSON: a step event as each phase begins,
+                // then a final result event. Read the stream and drive the
+                // state machine; a response with no body (a host without
+                // streaming) settles straight to failed.
+                if (response.body === null || typeof response.body.getReader !== 'function') {
+                  settled = true;
+                  clearDeadline();
+                  move({ type: 'failed' });
+                  return Promise.resolve();
+                }
+                var reader = response.body.getReader();
+                var decoder = new TextDecoder();
+                var buffer = '';
+                function pump() {
+                  return reader.read().then(function (result) {
+                    if (result.done) {
+                      // The stream ended without a result event (a host that
+                      // cannot stream, a route that broke mid-stream): settle
+                      // to failed so the control does not sit on a phase label.
+                      if (!settled) {
+                        settled = true;
+                        clearDeadline();
+                        move({ type: 'failed' });
+                      }
+                      return;
+                    }
+                    buffer += decoder.decode(result.value, { stream: true });
+                    var lines = buffer.split('\n');
+                    buffer = lines.pop();
+                    for (var i = 0; i < lines.length; i++) {
+                      var line = lines[i];
+                      if (line === '') {
+                        continue;
+                      }
+                      var event;
+                      try {
+                        event = JSON.parse(line);
+                      } catch {
+                        // A malformed line is not a launch event; skip it.
+                        continue;
+                      }
+                      if (event.step !== undefined) {
+                        move({ type: 'step', step: event.step });
+                        // The build step writes a "Building..." separator to
+                        // the live Logs buffer, so the build reads as a fresh
+                        // section the way the launch click writes
+                        // "Launching...".
+                        if (event.step === 'build') {
+                          getLogsState[1]((current) => {
+                            var base = current !== null ? current : '';
+                            return base + (base === '' ? '' : '\n') + '--- ' + t.entryBuilding + '\n';
+                          });
+                        }
+                        // Arm the deadline only for the launch (health-poll)
+                        // step; the rebuild steps run without a timeout.
+                        if (event.step === 'launch') {
+                          armDeadline();
+                        }
+                      } else if (event.result !== undefined) {
+                        settled = true;
+                        clearDeadline();
+                        var healthy = event.result.healthy === true;
+                        // A launch that is still fetching its model files reads
+                        // as downloading (a busy throbber the card re-polls),
+                        // not as a failure; only a result that is neither
+                        // healthy nor downloading settles to the red Logs.
+                        if (healthy) {
+                          move({ type: 'healthy' });
+                        } else if (event.result.state === 'downloading') {
+                          move({ type: 'downloading' });
+                        } else {
+                          move({ type: 'failed' });
+                        }
+                        // The provider status dots price the process probe on a
+                        // summary fetch, so a launch that turned an engine
+                        // healthy re-fetches the summary to repaint the dot
+                        // from red to green.
+                        fetchSummary(provider.engine, provider.config || {});
+                        return;
+                      }
+                    }
+                    return pump();
+                  });
+                }
+                return pump();
               })
-              .catch(() => {
+              .catch(function () {
                 settled = true;
-                clearTimeout(deadline);
-                entryLaunchState[1]((current) =>
-                  Object.assign({}, current, {
-                    [provider.id]: { status: 'failed', startTime: Date.now() },
-                  }),
-                );
+                clearDeadline();
+                move({ type: 'failed' });
               });
           },
-          [entryLaunch, fetchSummary],
+          [entryLaunch, fetchSummary, startProcessLog, moveEntry, getLogsState, t],
         );
 
+        // The per-entry stop: a running engine's Stop control moves the
+        // provider state machine to stopping (the control shows the throbber,
+        // disabled, the same display the launch phases show). For the duration
+        // of the stop action the card re-fetches the summary on a fast cadence
+        // so the provider's status dot repaints the moment the engine is down,
+        // instead of waiting out the host's 5-second process-watch cycle. A
+        // provider still running when the 10-second deadline fires settles to
+        // the red Logs state (the same path a failed launch takes); the Logs
+        // control opens the entry for editing and resets the machine to
+        // running, so the control reads as Stop again. The stop clears the
+        // launch record on this entry, so a recycled pid cannot re-link it.
         var onStopEntry = react.useCallback(
           (provider) => {
+            var prior = entryLaunch[provider.id];
+            var priorStatus = prior !== undefined ? prior.status : 'idle';
+            // A failed launch reads as Logs, not Stop, so a stop only starts
+            // from the other states.
+            if (priorStatus === 'failed') {
+              return;
+            }
+            var move = function (event) {
+              moveEntry(provider.id, event);
+            };
+            var clearStopTimers = function () {
+              if (stopTimersRef.current.poll !== null) {
+                clearTimeout(stopTimersRef.current.poll);
+                stopTimersRef.current.poll = null;
+              }
+              if (stopTimersRef.current.deadline !== null) {
+                clearTimeout(stopTimersRef.current.deadline);
+                stopTimersRef.current.deadline = null;
+              }
+            };
+            // A second Stop click re-arms the timers, so clear the in-flight
+            // ones first, or they would stack and double-settle.
+            clearStopTimers();
+            move({ type: 'stop' });
+            var poll = function () {
+              var status = providerStatusRef.current[provider.id];
+              if (status !== undefined && status !== 'running') {
+                // The provider is no longer running: the stop succeeded.
+                move({ type: 'stopped' });
+                clearStopTimers();
+                return;
+              }
+              fetchSummaryRef.current(null, null);
+              stopTimersRef.current.poll = setTimeout(poll, STOP_POLL_MS);
+            };
+            stopTimersRef.current.poll = setTimeout(poll, STOP_POLL_MS);
+            stopTimersRef.current.deadline = setTimeout(function () {
+              // The provider is still running after the deadline: settle to
+              // the red Logs state, the same path a failed launch takes.
+              clearStopTimers();
+              move({ type: 'stopFailed' });
+            }, STOP_HEALTH_DEADLINE_MS);
             fetch('/local-infer/stop', {
               method: 'POST',
               headers: { 'content-type': 'application/json' },
@@ -2846,32 +3603,32 @@ window.__ModuleLoader__.load({
                 providerId: provider.id,
               }),
             })
-              .then(() => {
-                entryLaunchState[1]((current) => {
-                  var next = Object.assign({}, current);
-                  delete next[provider.id];
-                  return next;
-                });
-              })
               .catch(() => {
-                /* a stop that fails leaves the entry in its last state */
+                /* a stop that fails leaves the entry in its last state; the
+                   fast-poll and the deadline settle it */
               });
           },
-          [],
+          [entryLaunch, moveEntry],
         );
 
         // The per-entry Logs control: opening the logs loads the entry for
-        // editing AND clears the failed launch state, so the per-entry control
-        // reads as Launch again. The user fixes the config in the form and
-        // re-launches from the same entry, instead of being stuck on a
+        // editing AND resets the launch state machine to idle, so the per-entry
+        // control reads as Launch again. The user fixes the config in the form
+        // and re-launches from the same entry, instead of being stuck on a
         // non-actionable Logs control.
         var onLogsEntry = react.useCallback(
           (provider) => {
             onEditProvider(provider);
             entryLaunchState[1]((current) => {
-              var next = Object.assign({}, current);
-              delete next[provider.id];
-              return next;
+              var entry = current[provider.id] || { status: 'idle' };
+              var next = launchNextState(entry, { type: 'reset' });
+              var map = Object.assign({}, current);
+              if (next.status === 'idle') {
+                delete map[provider.id];
+              } else {
+                map[provider.id] = Object.assign({}, next, { startTime: Date.now() });
+              }
+              return map;
             });
           },
           [onEditProvider],
@@ -2956,9 +3713,14 @@ window.__ModuleLoader__.load({
                   : null,
               )
             : null,
-          // The card header: the section title plus the circular "?" button
-          // that shows or hides the per-field descriptions. The preference
-          // persists through the save route, so it survives a reload.
+          // The card header: the section title plus the circular refresh and
+          // "?" buttons. The refresh button re-fetches the summary and deps
+          // from the host, so the card re-prices after the harness pauses
+          // the plugin's routes and re-activates them. The refresh glyph is
+          // the primitives seed's IconRefreshOutlineRegular; a host without
+          // the seed keeps the native arrow character. The "?" button shows
+          // or hides the per-field descriptions; the preference persists
+          // through the save route, so it survives a reload.
           react.createElement(
             'div',
             {
@@ -2971,16 +3733,39 @@ window.__ModuleLoader__.load({
             },
             react.createElement('div', { style: { fontWeight: 600, fontSize: 14 } }, t.section),
             react.createElement(
-              'button',
+              'div',
               {
-                type: 'button',
-                style: HELP_BUTTON_STYLE(help),
-                title: t.helpToggle,
-                'aria-label': t.helpToggle,
-                'aria-pressed': help,
-                onClick: () => onToggleHelp(!help),
+                style: {
+                  display: 'flex',
+                  alignItems: 'center',
+                  gap: 8,
+                },
               },
-              '?',
+              react.createElement(
+                'button',
+                {
+                  type: 'button',
+                  style: HELP_BUTTON_STYLE(false),
+                  title: t.refresh,
+                  'aria-label': t.refresh,
+                  onClick: () => load(),
+                },
+                primitives && typeof primitives.IconRefreshOutlineRegular === 'function'
+                  ? react.createElement(primitives.IconRefreshOutlineRegular, { size: 12 })
+                  : '↻',
+              ),
+              react.createElement(
+                'button',
+                {
+                  type: 'button',
+                  style: HELP_BUTTON_STYLE(help),
+                  title: t.helpToggle,
+                  'aria-label': t.helpToggle,
+                  'aria-pressed': help,
+                  onClick: () => onToggleHelp(!help),
+                },
+                '?',
+              ),
             ),
           ),
           // The provider list: the saved provider entries, each a collapsed
@@ -3010,8 +3795,12 @@ window.__ModuleLoader__.load({
                 onLogs: onLogsEntry,
                 launchLabel: t.entryLaunch,
                 stopLabel: t.entryStop,
+                stoppingLabel: t.stopping,
                 logsLabel: t.entryLogs,
-                launchingLabel: t.launching,
+                launchingLabel: t.entryLaunching,
+                prereqsLabel: t.entryPrereqs,
+                downloadingLabel: t.entryDownloading,
+                buildingLabel: t.entryBuilding,
               })
             : null,
           // The provider form: the Engine/Model config the card prices. It is
@@ -3176,13 +3965,13 @@ window.__ModuleLoader__.load({
                   },
                   t.hfCliDetected + ' ' + status.downloadCommand,
                 ),
-                renderButton(
-                  react,
-                  primitives,
-                  'ghost',
-                  { onClick: onDownload, disabled: downloading },
-                  downloading ? t.downloading : t.download,
-                ),
+                renderProcessButton(react, primitives, {
+                  busy: downloading === true,
+                  label: t.download,
+                  busyLabel: t.downloading,
+                  variant: 'ghost',
+                  onClick: onDownload,
+                }),
               );
             }
             return react.createElement(
@@ -3235,18 +4024,15 @@ window.__ModuleLoader__.load({
                   (status.hfCli ? t.hfCliDetected : t.noHfCli) + ' ' + status.downloadCommand,
                 ),
                 status.hfCli
-                  ? renderButton(
-                      react,
-                      primitives,
-                      'ghost',
-                      {
-                        onClick: function () {
-                          onDownloadTemplate(status.repo);
-                        },
-                        disabled: templateDownloading,
+                  ? renderProcessButton(react, primitives, {
+                      busy: templateDownloading === true,
+                      label: t.templateDownload,
+                      busyLabel: t.templateDownloading,
+                      variant: 'ghost',
+                      onClick: function () {
+                        onDownloadTemplate(status.repo);
                       },
-                      templateDownloading ? t.templateDownloading : t.templateDownload,
-                    )
+                    })
                   : null,
               ),
               templateDownloadNote !== ''
@@ -3314,6 +4100,94 @@ window.__ModuleLoader__.load({
                 ),
               ),
               help ? renderHelpRow(react, t.engineForkHelp) : null,
+              (() => {
+                // The build-method-dependent platform fields: local build mode
+                // shows the Build commands override, docker build mode shows the
+                // Docker tag override. Only one is visible at a time, keyed off
+                // the same buildMode the Build row prices. The placeholder seeds
+                // the engine's own default (the build step the deploy runs, or the
+                // image tag the docker deploy pulls), so an empty field reads as
+                // "use the default."
+                var engineEntry = (data.engines || []).find(
+                  (entry) => entry.id === draft.engine,
+                );
+                var buildModes = [];
+                if (engineEntry && engineEntry.supports.local) buildModes.push('local');
+                if (engineEntry && engineEntry.supports.docker) buildModes.push('docker');
+                var buildMode =
+                  typeof draft.config.buildMode === 'string'
+                    ? draft.config.buildMode
+                    : buildModes[0] || 'local';
+                if (buildMode === 'local') {
+                  return react.createElement(
+                    'div',
+                    null,
+                    react.createElement(
+                      'div',
+                      { style: ROW_STYLE },
+                      react.createElement('label', { style: LABEL_STYLE }, t.buildCommands),
+                      react.createElement(
+                        'input',
+                        Object.assign(
+                          { style: INPUT_STYLE },
+                          {
+                            type: 'text',
+                            value:
+                              typeof enginePlatform.buildCommands === 'string'
+                                ? enginePlatform.buildCommands
+                                : '',
+                            placeholder:
+                              engineEntry && engineEntry.defaultBuildCommand
+                                ? engineEntry.defaultBuildCommand
+                                : '',
+                            onChange: (event) =>
+                              onPlatform(
+                                'buildCommands',
+                                event.target.value === '' ? undefined : event.target.value,
+                              ),
+                          },
+                        ),
+                      ),
+                    ),
+                    help ? renderHelpRow(react, t.buildCommandsHelp) : null,
+                  );
+                }
+                if (buildMode === 'docker') {
+                  return react.createElement(
+                    'div',
+                    null,
+                    react.createElement(
+                      'div',
+                      { style: ROW_STYLE },
+                      react.createElement('label', { style: LABEL_STYLE }, t.dockerTag),
+                      react.createElement(
+                        'input',
+                        Object.assign(
+                          { style: INPUT_STYLE },
+                          {
+                            type: 'text',
+                            value:
+                              typeof enginePlatform.dockerTag === 'string'
+                                ? enginePlatform.dockerTag
+                                : '',
+                            placeholder:
+                              engineEntry && engineEntry.defaultDockerTag
+                                ? engineEntry.defaultDockerTag
+                                : '',
+                            onChange: (event) =>
+                              onPlatform(
+                                'dockerTag',
+                                event.target.value === '' ? undefined : event.target.value,
+                              ),
+                          },
+                        ),
+                      ),
+                    ),
+                    help ? renderHelpRow(react, t.dockerTagHelp) : null,
+                  );
+                }
+                return null;
+              })(),
             );
           })(),
           hasFields
@@ -3322,17 +4196,28 @@ window.__ModuleLoader__.load({
                   'div',
                   { key: section.group },
                   react.createElement('div', { style: SECTION_STYLE }, section.group),
-                  section.fields.map((field) =>
-                    renderField(
+                  section.fields.map((field) => {
+                    // The field value binds to the local draft, not the server
+                    // render model, so a typed keystroke shows in the input
+                    // immediately. The server model (field.value) resolves the
+                    // spec default and only surfaces after the debounced
+                    // re-price settles. A key the user has not edited is
+                    // absent from the draft, so it falls back to the model.
+                    var draftValue = draft.config[field.key];
+                    var effectiveField =
+                      draftValue !== undefined
+                        ? Object.assign({}, field, { value: draftValue })
+                        : field;
+                    return renderField(
                       react,
-                      field,
+                      effectiveField,
                       onValue,
                       inlineWarnings[field.key],
                       primitives,
                       help,
                       t,
-                    ),
-                  ),
+                    );
+                  }),
                 ),
               )
             : react.createElement('div', { style: { fontSize: 12, opacity: 0.7 } }, t.noParameters),
@@ -3408,37 +4293,92 @@ window.__ModuleLoader__.load({
               onAllowRun: onAllowRun,
               onRun: onRun,
               onGet: onGet,
+              getting: getting,
               installing: installing,
               copyNote: copyNote,
               depsNote: depsNote,
             },
             primitives,
           ),
-          // The Logs section: the last run's captured output in a fixed-height
-          // read-only text area (a launch fills it; the card never edits it),
-          // and the log-file location the launch writes to. The location field
-          // edits the template the route resolves and writes on the next run.
+          // The Logs section: the last run's captured output in a read-only
+          // text area (a launch fills it; the card never edits it), and the
+          // log-file location the launch writes to. The location field edits
+          // the template the route resolves and writes on the next run. While
+          // a Get is in flight the streamed buffer wins: the git sync,
+          // dependency, and build output appends there as it lands.
+          //
+          // The textarea auto-scrolls to the bottom while the scroll mode is
+          // 'fresh' (the pane just opened) or 'scrolling'; a manual scroll up
+          // parks the mode at 'manual' so updates stop moving the view, and a
+          // scroll back to the bottom re-arms 'scrolling'. The diagonal
+          // chevron in the section's bottom-right corner drags the height
+          // vertically only.
           react.createElement(
             'div',
             { style: { marginTop: 8 } },
             react.createElement('div', { style: LABEL_STYLE }, t.logs),
-            react.createElement('textarea', {
-              style: {
-                width: '100%',
-                height: 96,
-                resize: 'none',
-                fontFamily: 'monospace',
-                fontSize: 11,
-                padding: 6,
-                border: '1px solid rgba(127,127,127,0.25)',
-                borderRadius: 6,
-                color: 'inherit',
-                background: 'transparent',
-              },
-              value: data.lastLogs || '',
-              readOnly: true,
-              'aria-label': t.logs,
-            }),
+            react.createElement(
+              'div',
+              { style: { position: 'relative' } },
+              react.createElement('textarea', {
+                ref: logsTextareaRef,
+                style: {
+                  width: '100%',
+                  height: logsHeight,
+                  boxSizing: 'border-box',
+                  resize: 'none',
+                  fontFamily: 'monospace',
+                  fontSize: 11,
+                  padding: 6,
+                  border: '1px solid rgba(127,127,127,0.25)',
+                  borderRadius: 6,
+                  color: 'inherit',
+                  background: 'transparent',
+                },
+                value: displayedLogs,
+                readOnly: true,
+                onScroll: onLogsScroll,
+                'aria-label': t.logs,
+              }),
+              // The diagonal resize chevron: a DSH primitives down chevron
+              // rotated -45 degrees points into the bottom-right corner and
+              // reads as a resize handle. Dragging it vertically resizes the
+              // section; a host without the seed keeps the native corner glyph.
+              react.createElement(
+                'div',
+                {
+                  style: {
+                    position: 'absolute',
+                    bottom: 0,
+                    right: 0,
+                    width: 16,
+                    height: 16,
+                    display: 'flex',
+                    alignItems: 'flex-end',
+                    justifyContent: 'flex-end',
+                    cursor: 'ns-resize',
+                    color: 'var(--dsw-alias-label-tertiary, rgba(127,127,127,0.8))',
+                    userSelect: 'none',
+                    touchAction: 'none',
+                  },
+                  onPointerDown: onLogsResizeStart,
+                  role: 'button',
+                  'aria-label': t.logs + ' ' + t.resize,
+                },
+                primitives && typeof primitives.IconChevronDownOutlineRegular === 'function'
+                  ? react.createElement(
+                      'span',
+                      {
+                        style: {
+                          display: 'inline-flex',
+                          transform: 'rotate(-45deg)',
+                        },
+                      },
+                      react.createElement(primitives.IconChevronDownOutlineRegular, { size: 12 }),
+                    )
+                  : '\u231F',
+              ),
+            ),
             react.createElement(
               'div',
               { style: ROW_STYLE },
@@ -3455,46 +4395,78 @@ window.__ModuleLoader__.load({
           // draft's engine is down, Stop while a healthy launch set draftRunning,
           // and an in-flight spinner (disabled) while a launch or stop is in
           // flight. Launch stays disabled while the deps panel reports a
-          // missing host dependency, the same gate the panel's "Get" button
-          // reads. The note reports the answer the route returned.
+          // missing host dependency or a Get run is in flight, and re-enables
+          // when the build finishes, errors, or falls silent for GET_IDLE_MS.
+          // The Auto Rebuild checkbox sits after the control: checked, a
+          // launch runs the git sync (fetch, rebase, rebuild) first;
+          // unchecked, the launch starts the checkout as-is. The note reports
+          // the answer the route returned.
           react.createElement(
             'div',
             { style: { display: 'flex', alignItems: 'center', gap: 8, marginTop: 8 } },
-            launching
-              ? react.createElement(
-                  'button',
-                  {
-                    type: 'button',
-                    disabled: true,
-                    style: Object.assign(
-                      { display: 'inline-flex', alignItems: 'center', gap: 4, opacity: 0.7 },
-                      GHOST_BUTTON,
-                    ),
-                    'aria-label': t.launching,
-                  },
-                  renderThrobber(react, primitives),
-                  react.createElement('span', null, t.launching),
-                )
-              : stopping
-                ? renderButton(
-                    react,
-                    primitives,
-                    'ghost',
-                    { onClick: function () {}, disabled: true },
-                    t.stopping,
-                  )
-                : draftRunning
-                  ? renderButton(react, primitives, 'ghost', { onClick: onStop }, t.stop)
-                  : renderButton(
-                      react,
-                      primitives,
-                      'primary',
+            mirroredPhaseLabel !== undefined
+              ? renderProcessButton(react, primitives, {
+                  busy: true,
+                  label: mirroredPhaseLabel,
+                  busyLabel: mirroredPhaseLabel,
+                  variant: 'ghost',
+                  onClick: function () {},
+                })
+              : mirroredStatus === 'running'
+                ? renderButton(react, primitives, 'ghost', {
+                    onClick: function () {
+                      onStopEntry(editedProvider);
+                    },
+                  }, t.stop)
+                : mirroredStatus === 'failed'
+                  ? react.createElement(
+                      'button',
                       {
-                        onClick: onLaunch,
-                        disabled: deps !== null && deps.allSatisfied !== true,
+                        type: 'button',
+                        onClick: function () {
+                          onLogsEntry(editedProvider);
+                        },
+                        style: Object.assign(
+                          { color: 'var(--dsw-alias-label-error, #ff3b30)' },
+                          GHOST_BUTTON,
+                        ),
+                        'aria-label': t.entryLogs,
                       },
-                      t.launch,
-                    ),
+                      t.entryLogs,
+                    )
+                  : renderProcessButton(react, primitives, {
+                      busy: launching || stopping,
+                      label: draftRunning ? t.stop : t.launch,
+                      busyLabel: launching ? t.launching : t.stopping,
+                      variant: draftRunning ? 'ghost' : 'primary',
+                      // While a provider is being edited, the control drives the
+                      // provider state machine (the same entry the title bar
+                      // mirrors), so the throbber, the fast-poll, and the
+                      // 10-second Logs deadline apply. A fresh provider (no
+                      // entry) keeps the draft-based Launch/Stop.
+                      onClick: draftRunning
+                        ? editedProvider !== undefined
+                          ? function () {
+                              onStopEntry(editedProvider);
+                            }
+                          : onStop
+                        : editedProvider !== undefined
+                          ? function () {
+                              onLaunchEntry(editedProvider);
+                            }
+                          : onLaunch,
+                      disabled:
+                        !draftRunning &&
+                        (getting || (deps !== null && deps.allSatisfied !== true)),
+                    }),
+            // The Auto Rebuild checkbox: checked, a launch runs the git sync
+            // (fetch, rebase, rebuild) before the spawn; unchecked, the
+            // launch starts the checkout as-is.
+            renderCheckbox(react, primitives, {
+              checked: autoRebuild,
+              onChange: (next) => autoRebuildState[1](next),
+              label: t.autoRebuild,
+            }),
           ),
           lifecycleNote
             ? react.createElement('div', { style: { fontSize: 12 } }, lifecycleNote)