dsh-plugin-local-infer 0.1.1 → 0.1.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "publishConfig": {
     "access": "public"
   },
@@ -21,7 +21,12 @@
     "ai-agent"
   ],
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cybtachyon/dsh-plugin-local-infer"
+  },
   "type": "module",
+  "packageManager": "pnpm@12.11.2",
   "engines": {
     "node": "^22.19.0 || >=24.0.0"
   },
@@ -85,22 +90,23 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.5-alpha.2"
   },
+  "scripts": {
+    "build": "tsc -b",
+    "typecheck": "tsc -b",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "lint": "eslint .",
+    "clean": "tsc -b --clean"
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^22.10.0",
     "@vitest/coverage-v8": "^5.0.4",
     "eslint": "^10.12.0",
+    "tsx": "^4.23.15",
     "typescript": "^5.9.0",
     "typescript-eslint": "^8.71.2",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^5.0.4"
-  },
-  "scripts": {
-    "build": "tsc -b",
-    "typecheck": "tsc -b",
-    "test": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "lint": "eslint .",
-    "clean": "tsc -b --clean"
   }
-}
+}

package/packages/core/lib/adapter.d.ts

@@ -5,6 +5,13 @@ import type { HardwareProfile } from './hardware.ts';
 import type { ParameterSpec } from './parameter.ts';
 import type { SystemDep } from './deps.ts';
 import type { EngineLaunchSignature } from './reserve.ts';
+/**
+ * BuildMode is the deploy mode an engine renders a plan for: a docker
+ * container, a local source build, or a prebuilt binary install (the Strata
+ * Terminal the install script places on the path). The adapter reads it from
+ * the config `buildMode` field and renders the matching plan.
+ */
+export type BuildMode = 'docker' | 'local' | 'binary';
 /**
  * LaunchPlan is the engine-neutral result of rendering a config: how to start
  * the engine (a local process, a docker container, or a compose file), the
@@ -21,6 +28,7 @@ export interface LaunchPlan {
     env?: Record<string, string>;
     composeFile?: string;
     profile?: string;
+    composeArgs?: string;
     containerName?: string;
     modelId?: string;
     modelDirectory?: string;
@@ -32,12 +40,31 @@ export interface LaunchPlan {
  * specific engine: where the engine platform lives locally (the checkout and
  * build location) and the git repo that overrides the engine's default
  * upstream for this config. The deploy step consumes both: it clones the fork
- * (or the default upstream) into the engine directory.
+ * (or the default upstream) into the engine directory. `buildCommands`
+ * overrides the engine's local build command (the local build mode) and
+ * `dockerTag` overrides the docker image tag the docker deploy pulls (the
+ * docker build mode); each rides the platform map, so an engine switch keeps
+ * them.
  */
 export interface EnginePlatformConfig {
     engineId: string;
     engineDirectory?: string;
     engineFork?: string;
+    buildCommands?: string;
+    dockerTag?: string;
+}
+/**
+ * ProcessExitInfo is the one-shot answer to a spawned process's lifetime end:
+ * the exit code (null when a signal or a spawn failure ended it), the signal
+ * name (null when the process exited on its own), and the spawn error message
+ * when the child never ran (a missing binary). The host emits it exactly once
+ * per child, from the close event or the error event, so a crash or a pkill
+ * reaches the plugin's state through one seam instead of an uncaughtException.
+ */
+export interface ProcessExitInfo {
+    code: number | null;
+    signal: string | null;
+    error?: string;
 }
 /**
  * ProcessHandle is the handle to a spawned engine process: its pid and a kill
@@ -46,12 +73,17 @@ export interface EnginePlatformConfig {
  * the host captures the child's stdout and stderr, is the accumulated output
  * the launch step surfaces in the card's Logs section and writes to the log
  * file. A host that does not capture streams (a container it cannot read)
- * omits it.
+ * omits it. `onExit`, when the host watches the child, registers a listener
+ * fired once with the ProcessExitInfo when the child ends (a crash, a signal
+ * like a pkill, or a clean stop); a listener registered after the child has
+ * already ended fires immediately. A host that cannot watch (a stub, or a
+ * container it cannot read) omits it.
  */
 export interface ProcessHandle {
     pid: number;
     kill(): void;
     logs?: string;
+    onExit?(listener: (exit: ProcessExitInfo) => void): void;
 }
 /**
  * FetchResult is the answer to a health poll: the HTTP status and whether it
@@ -71,6 +103,15 @@ export interface FetchResult {
  */
 export interface LifecycleHost {
     run(command: string): Promise<CommandOutcome>;
+    /**
+     * Optional: run a command line and stream each stdout/stderr chunk to
+     * onOutput while it runs, so the Get step can append build output to the
+     * card's Logs section as it lands. A host that cannot stream omits it,
+     * and the caller falls back to run. No overall timeout: a full CUDA
+     * build legitimately runs past any fixed cap, and the card prices a
+     * stalled step with its own output-idle watchdog.
+     */
+    runStream?(command: string, onOutput: (chunk: string) => void): Promise<CommandOutcome>;
     spawn(argv: readonly string[], env: Record<string, string>, cwd?: string): ProcessHandle;
     fetch(url: string): Promise<FetchResult>;
     debug?: DebugLogger;
@@ -84,26 +125,75 @@ export interface HealthCheckOptions {
     pollMs?: number;
     maxAttempts?: number;
 }
+/**
+ * LaunchStep is the phase of a launch the card's Launch control prices: the
+ * system-dependency install (prereqs), the model and git checkout download
+ * (download), the source build or image pull (build), and the health poll that
+ * waits for the engine to come ready (launch). The service and the adapters
+ * report the step as each phase begins, so the card's button reads the phase
+ * that is actually running instead of a single "Launching..." for the whole
+ * rebuild. The card times out only the launch step; the rebuild steps (prereqs,
+ * download, build) run as long as they need to.
+ */
+export type LaunchStep = 'prereqs' | 'download' | 'build' | 'launch';
+/**
+ * LaunchProgress is the callback the launch flow calls as each phase begins.
+ * The route threads it from the streamed launch response through the service
+ * and the adapter's deploy step; a launch with no progress sink omits it.
+ */
+export type LaunchProgress = (step: LaunchStep) => void;
+/**
+ * EngineLaunchState is the phase of an engine start the health poll reports:
+ * downloading (the engine is fetching its engine or model files, the health
+ * endpoint is not up yet), starting (the files are in place and the engine is
+ * coming up), ready (the health endpoint reports 200), and failed (the start
+ * did not reach readiness). An engine that downloads before it can serve (the
+ * Strata Terminal) spends a long time in downloading, so the poll reports the
+ * phase instead of timing out and reading the start as broken.
+ */
+export type EngineLaunchState = 'downloading' | 'starting' | 'ready' | 'failed';
 /**
  * HealthResult is the answer to a /health poll: whether the engine is up, the
- * HTTP status, and a detail string for the UI.
+ * HTTP status, a detail string for the UI, and the start phase the poll
+ * observed (absent for an engine whose start has no download phase).
  */
 export interface HealthResult {
     healthy: boolean;
     status?: number;
     detail?: string;
+    state?: EngineLaunchState;
+}
+/**
+ * DeployOptions tunes a deploy run: `allowRunDeps` is the Play/Run trust gate
+ * (the card's "Allow one-click install (sudo)" checkbox). A local deploy that
+ * rebuilds the engine and leaves its binary out of the path links it into
+ * /usr/local/bin; the gate decides whether that sudo link runs (on) or is
+ * written to the card's Logs section for the user to run (off). `autoRebuild`
+ * is the card's "Auto Rebuild" checkbox: when false, the git sync (fetch,
+ * rebase, and the conditional rebuild) is skipped and the checkout launches
+ * as-is. Absent reads as true (the rebuild runs).
+ */
+export interface DeployOptions {
+    allowRunDeps?: boolean;
+    autoRebuild?: boolean;
 }
 /**
  * DeployResult reports whether a build-or-pull succeeded, with a detail for the
  * UI. `handle` is the spawned engine process when the deploy step started one
  * locally: the service reads its accumulated `logs` after the health poll, so
  * the launch result carries the engine's output for the card's Logs section and
- * the log file. A deploy that only pulls an image omits it.
+ * the log file, and attaches the handle's `onExit` listener to learn of a crash
+ * or a pkill. A deploy that starts no process (a compose up) omits it. `logs`
+ * is the deploy step's own captured output (the rebuild decision, the build
+ * command, and its output) the service prepends to the engine's output, so the
+ * card's Logs section shows the build a launch ran. A deploy that runs no
+ * rebuild (a docker pull, a compose up) omits it.
  */
 export interface DeployResult {
     ok: boolean;
     detail?: string;
     handle?: ProcessHandle;
+    logs?: string;
 }
 /**
  * EngineAdapter is the abstract base one subclass implements per engine. It
@@ -119,11 +209,12 @@ export declare abstract class EngineAdapter {
     abstract readonly supports: {
         docker: boolean;
         local: boolean;
+        binary?: boolean;
     };
     abstract parameters(): readonly ParameterSpec[];
     abstract renderLaunch(config: Config, hw: HardwareProfile): LaunchPlan;
     abstract healthCheck(plan: LaunchPlan, options?: HealthCheckOptions): Promise<HealthResult>;
-    abstract deploy(plan: LaunchPlan, platform?: EnginePlatformConfig): Promise<DeployResult>;
+    abstract deploy(plan: LaunchPlan, platform?: EnginePlatformConfig, onProgress?: LaunchProgress, options?: DeployOptions): Promise<DeployResult>;
     abstract stop(plan: LaunchPlan): Promise<void>;
     /**
      * Optional: the host deps this engine's deploy step needs for a build mode,
@@ -131,7 +222,7 @@ export declare abstract class EngineAdapter {
      * registered adapter first and falls back to the provider-registered plan
      * for the engine id when the adapter declares none.
      */
-    systemDeps?(buildMode: 'docker' | 'local', hw: HardwareProfile): readonly SystemDep[];
+    systemDeps?(buildMode: BuildMode, hw: HardwareProfile): readonly SystemDep[];
     /**
      * Optional: the model the engine serves under a config: the id the engine
      * advertises on its OpenAI endpoint and the display name the registrar
@@ -143,6 +234,28 @@ export declare abstract class EngineAdapter {
         id: string;
         name: string;
     } | undefined;
+    /**
+     * Optional: the model the running engine actually serves, read live from the
+     * engine (a terminal query against its model endpoint) rather than derived
+     * from the config. An engine that sizes and picks the model itself publishes
+     * the served id this returns instead of the config-derived modelRef; it
+     * returns undefined when the engine is not up, the answer cannot be read, or
+     * the config names a model, and the route falls back to modelRef. The
+     * register, save-sync, unregister, and summary paths await it, so it must
+     * never reject.
+     */
+    discoverModel?(config: Config): Promise<{
+        id: string;
+        name: string;
+    } | undefined>;
+    /**
+     * Optional: the request modalities the engine serves under a config, the
+     * input types the DSH model row carries. An engine whose vision control is
+     * not the plain boolean flag (Strata's on|off|gpu|cpu enum, on by default)
+     * declares this so the Image input follows the engine's own vocabulary; an
+     * engine that declares none keeps the register step's boolean rule.
+     */
+    modelInput?(config: Config): string[] | undefined;
     /**
      * Optional: the launch signature the engine's toArgv/toEnv produce for a
      * config: the binary (or docker image) it runs under, the port it binds,

package/packages/core/lib/deps.d.ts

@@ -1,4 +1,4 @@
-import type { EngineAdapter } from './adapter.ts';
+import type { BuildMode, EngineAdapter } from './adapter.ts';
 import type { HardwareProfile } from './hardware.ts';
 /**
  * DepStatus is the lifecycle state of one host dependency: satisfied, missing,
@@ -60,6 +60,7 @@ export interface SystemDep {
 export interface EngineDepPlan {
     docker: readonly SystemDep[];
     local: readonly SystemDep[];
+    binary?: readonly SystemDep[];
 }
 /**
  * DepCheck is the per-dep answer from checkDeps: the dep and its current
@@ -103,7 +104,7 @@ export interface InstallResult {
  * service implements this interface over the pure functions below.
  */
 export interface SystemDepProvisioner {
-    planDeps(engine: EngineAdapter, buildMode: 'docker' | 'local', hw: HardwareProfile): readonly SystemDep[];
+    planDeps(engine: EngineAdapter, buildMode: BuildMode, hw: HardwareProfile): readonly SystemDep[];
     checkDeps(deps: readonly SystemDep[], hw: HardwareProfile): Promise<DepCheck[]>;
     renderInstallString(deps: readonly SystemDep[], hw: HardwareProfile): string;
     runInstall(deps: readonly SystemDep[], hw: HardwareProfile, runCommand: CommandRunner): Promise<InstallResult>;
@@ -122,7 +123,7 @@ export declare function detectPackageManager(probes: PackageManagerProbes): Pack
  * declares none (the Phase 5 adapters will) plans an empty list, and the
  * service falls back to the provider-registered plan for the engine id.
  */
-export declare function planDeps(engine: EngineAdapter, buildMode: 'docker' | 'local', hw: HardwareProfile): readonly SystemDep[];
+export declare function planDeps(engine: EngineAdapter, buildMode: BuildMode, hw: HardwareProfile): readonly SystemDep[];
 /**
  * checkDeps probes every dep and reports its status. A dep without a detect
  * probe reads as missing, not satisfied: an unknown state degrades to the

package/packages/core/lib/index.d.ts

@@ -13,13 +13,14 @@ export { DEFAULT_OS_RESERVE_MIB, estimateVram, KV_PAGE_TOKENS, pageRoundUp, TIGH
 export type { EstimateContext, EstimateOptions, SpeculationTerms, VramBreakdown, VramContribution, VramEstimate, VramModel, VramVerdict, } from './estimator.ts';
 export { GPU_USAGE_BUSY_THRESHOLD, matchLaunchSignature, parseNvidiaSmiGpuUsage, resolveOsReserve, } from './reserve.ts';
 export { commandMatchesArgv, launchRecordFromPlan, reLinkRecord, } from './launch-record.ts';
+export { formatLaunchCommand } from './launch-command.ts';
 export type { ProviderLaunchRecord, ReLinkInput, ReLinkOutcome, } from './launch-record.ts';
 export type { EngineLaunchSignature, GpuUsageProbe, ProcessLine, ReserveResolution, ReserveSource, } from './reserve.ts';
 export { computeProviderStatuses, isGpuBusy, } from './status.ts';
 export type { ProviderRef, ProviderStatus, ProviderStatusInput, RunningEngineRef, } from './status.ts';
 export { DEFAULT_LOG_PATH_TEMPLATE, LOG_FILE_NAME_TEMPLATE, LOG_TEMPLATE_ENGINE, LOG_TEMPLATE_HOME, LOG_TEMPLATE_MODEL, LOG_TEMPLATE_TIMESTAMP, formatLogTimestamp, resolveLogPath, slugifyModelName, } from './logs.ts';
 export { EngineAdapter } from './adapter.ts';
-export type { DeployResult, EnginePlatformConfig, FetchResult, HealthCheckOptions, HealthResult, LaunchPlan, LifecycleHost, ProcessHandle, } from './adapter.ts';
+export type { BuildMode, DeployOptions, DeployResult, EngineLaunchState, EnginePlatformConfig, FetchResult, HealthCheckOptions, HealthResult, LaunchPlan, LaunchProgress, LaunchStep, LifecycleHost, ProcessExitInfo, ProcessHandle, } from './adapter.ts';
 export { NOOP_DEBUG_LOGGER, createCommandDebugLogger, isHarnessLogDebug, } from './debug.ts';
 export type { CreateCommandDebugLoggerArgs, DebugLogger, } from './debug.ts';
 export { constraintId, evaluateGuidelines, modelGuidelines } from './guideline.ts';

package/packages/core/lib/index.js

@@ -9,6 +9,7 @@ export { detectHardware, parseNvidiaSmiGpu, } from "./hardware.js";
 export { DEFAULT_OS_RESERVE_MIB, estimateVram, KV_PAGE_TOKENS, pageRoundUp, TIGHT_HEADROOM_BYTES, } from "./estimator.js";
 export { GPU_USAGE_BUSY_THRESHOLD, matchLaunchSignature, parseNvidiaSmiGpuUsage, resolveOsReserve, } from "./reserve.js";
 export { commandMatchesArgv, launchRecordFromPlan, reLinkRecord, } from "./launch-record.js";
+export { formatLaunchCommand } from "./launch-command.js";
 export { computeProviderStatuses, isGpuBusy, } from "./status.js";
 export { DEFAULT_LOG_PATH_TEMPLATE, LOG_FILE_NAME_TEMPLATE, LOG_TEMPLATE_ENGINE, LOG_TEMPLATE_HOME, LOG_TEMPLATE_MODEL, LOG_TEMPLATE_TIMESTAMP, formatLogTimestamp, resolveLogPath, slugifyModelName, } from "./logs.js";
 export { EngineAdapter } from "./adapter.js";

package/packages/core/lib/launch-command.d.ts

@@ -0,0 +1,13 @@
+import type { LaunchPlan } from './adapter.ts';
+/**
+ * formatLaunchCommand renders a launch plan as the shell command string the
+ * deploy step runs to start the engine: the quoted argv joined for a process
+ * or docker plan, or the `docker compose up` line for a compose plan. The
+ * card's Logs section shows the line above the engine's own output, so a
+ * user can read and copy the exact binary and arguments a launch started
+ * with. The Hyper-Qwen deploy runs this same string, so the printed line and
+ * the host command cannot drift. Returns undefined when the plan names no
+ * command (a non-compose plan with no argv).
+ */
+export declare function formatLaunchCommand(plan: LaunchPlan): string | undefined;
+//# sourceMappingURL=launch-command.d.ts.map

package/packages/core/lib/launch-command.js

@@ -0,0 +1,64 @@
+/**
+ * formatLaunchCommand renders a launch plan as the shell command string the
+ * deploy step runs to start the engine: the quoted argv joined for a process
+ * or docker plan, or the `docker compose up` line for a compose plan. The
+ * card's Logs section shows the line above the engine's own output, so a
+ * user can read and copy the exact binary and arguments a launch started
+ * with. The Hyper-Qwen deploy runs this same string, so the printed line and
+ * the host command cannot drift. Returns undefined when the plan names no
+ * command (a non-compose plan with no argv).
+ */
+export function formatLaunchCommand(plan) {
+    if (plan.kind === 'compose') {
+        // The user's compose arguments (the card's docker-tag field) override the
+        // default profile: the flags the up step runs before the required `up -d`.
+        // An empty field reads as "use the default profile", so the up step falls
+        // back to the engine's own default.
+        const composeArgs = plan.composeArgs?.split(/\s+/).filter((token) => token !== '');
+        if (composeArgs !== undefined && composeArgs.length > 0) {
+            return [
+                'docker',
+                'compose',
+                '-f',
+                plan.composeFile ?? 'docker-compose.yml',
+                ...composeArgs,
+                'up',
+                '-d',
+            ]
+                .map(quoteArg)
+                .join(' ');
+        }
+        // The compose defaults match the adapter's renderLaunch fallbacks, so a
+        // plan built from a bare config still spells a runnable command.
+        return [
+            'docker',
+            'compose',
+            '-f',
+            plan.composeFile ?? 'docker-compose.yml',
+            '--profile',
+            plan.profile ?? 'single',
+            'up',
+            '--pull',
+            'always',
+            '-d',
+        ]
+            .map(quoteArg)
+            .join(' ');
+    }
+    const argv = plan.argv;
+    if (argv === undefined || argv.length === 0)
+        return undefined;
+    return argv.map(quoteArg).join(' ');
+}
+/**
+ * quoteArg renders one argv token for display: a token made only of shell-
+ * safe characters rides bare, anything else lands in single quotes with
+ * embedded quotes escaped, so the printed line pastes back into a shell
+ * unchanged.
+ */
+function quoteArg(token) {
+    if (token !== '' && /^[A-Za-z0-9@%+=:,./_-]+$/.test(token))
+        return token;
+    return `'${token.replaceAll("'", "'\\''")}'`;
+}
+//# sourceMappingURL=launch-command.js.map

package/packages/core/lib/models.d.ts

@@ -67,7 +67,8 @@ export interface ModelDirectoryEntry {
 /**
  * modelEntriesForEngine filters a model directory listing down to the model
  * entries the engine's Model dropdown offers: NInfer takes `.ninfer`
- * artifacts, llama.cpp takes `.gguf` files, and Hyper-Qwen takes the repo
+ * artifacts, Infernix takes `.ninfer` artifacts and its own `.infernix`
+ * files, llama.cpp takes `.gguf` files, and Hyper-Qwen takes the repo
  * directories that hold a `.safetensors` weight file. Every other engine
  * (Strata) offers nothing, matching its empty default list. The result is
  * sorted, so the dropdown order is stable across summary fetches.

package/packages/core/lib/models.js

@@ -61,7 +61,8 @@ export function hfChatTemplateCommand(repo, directory) {
 /**
  * modelEntriesForEngine filters a model directory listing down to the model
  * entries the engine's Model dropdown offers: NInfer takes `.ninfer`
- * artifacts, llama.cpp takes `.gguf` files, and Hyper-Qwen takes the repo
+ * artifacts, Infernix takes `.ninfer` artifacts and its own `.infernix`
+ * files, llama.cpp takes `.gguf` files, and Hyper-Qwen takes the repo
  * directories that hold a `.safetensors` weight file. Every other engine
  * (Strata) offers nothing, matching its empty default list. The result is
  * sorted, so the dropdown order is stable across summary fetches.
@@ -74,6 +75,14 @@ export function modelEntriesForEngine(entries, engineId) {
                 .filter((entry) => !entry.isDirectory && entry.name.endsWith('.ninfer'))
                 .map((entry) => entry.name);
             break;
+        case 'infernix':
+            // Infernix loads NInfer artifacts unchanged plus its own `.infernix`
+            // files, so the dropdown offers both extensions.
+            names = entries
+                .filter((entry) => !entry.isDirectory &&
+                (entry.name.endsWith('.ninfer') || entry.name.endsWith('.infernix')))
+                .map((entry) => entry.name);
+            break;
         case 'llamacpp':
             names = entries
                 .filter((entry) => !entry.isDirectory && entry.name.endsWith('.gguf'))

package/packages/core/lib/registrar.d.ts

@@ -1,4 +1,4 @@
-import type { LaunchPlan } from './adapter.ts';
+import type { BuildMode, LaunchPlan } from './adapter.ts';
 /**
  * DshModelEntry is the shape of the model row the registrar writes into the
  * dsh-llm-pi-ai provider: the provider id, the model id and display name, the
@@ -83,11 +83,11 @@ export interface DshModelRegistrar {
 export declare function modelSlug(modelId: string): string;
 /**
  * providerIdFor derives the provider id the registrar writes for an engine
- * and model: the engine id, the build mode (local or docker), and the model
- * slug, so a profile can carry the same engine in both build modes and
- * several models per engine without a collision.
+ * and model: the engine id, the build mode (local, docker, or binary), and the
+ * model slug, so a profile can carry the same engine in several build modes
+ * and several models per engine without a collision.
  */
-export declare function providerIdFor(engineId: string, modelId: string, buildMode: 'local' | 'docker'): string;
+export declare function providerIdFor(engineId: string, modelId: string, buildMode: BuildMode): string;
 /**
  * apiKeyEnvFor derives the env-var name a local provider reads its optional
  * API key from: the engine id, uppercased and non-alphanumerics mapped to

package/packages/core/lib/registrar.js

@@ -27,9 +27,9 @@ export function modelSlug(modelId) {
 }
 /**
  * providerIdFor derives the provider id the registrar writes for an engine
- * and model: the engine id, the build mode (local or docker), and the model
- * slug, so a profile can carry the same engine in both build modes and
- * several models per engine without a collision.
+ * and model: the engine id, the build mode (local, docker, or binary), and the
+ * model slug, so a profile can carry the same engine in several build modes
+ * and several models per engine without a collision.
  */
 export function providerIdFor(engineId, modelId, buildMode) {
     return `${engineId}-${buildMode}-${modelSlug(modelId)}`;

package/packages/core/lib/status.d.ts

@@ -1,4 +1,5 @@
 import type { GpuUsageProbe } from './reserve.ts';
+import type { Config } from './config.ts';
 /**
  * ProviderStatus is the running-state the plugin card paints each saved
  * provider's status dot: green while the engine is confirmed serving the
@@ -10,12 +11,19 @@ export type ProviderStatus = 'running' | 'stopped' | 'unsure';
  * ProviderRef is the identity side of one saved provider config: the stable
  * id the card renders and the engine and model it serves. The model is
  * optional because a config that names no model cannot be confirmed against
- * a running engine, and reads as unsure rather than a guess.
+ * a running engine, and reads as unsure rather than a guess. The config is
+ * optional and lets the detector price the provider's own launch signature
+ * (the engine binary the build mode runs, the port it binds) rather than the
+ * adapter's default-port signature; the port is the resolved bind port the
+ * detector read from that signature, and the resolver ties a running engine
+ * to the provider only when the ports agree.
  */
 export interface ProviderRef {
     id: string;
     engine: string;
     model?: string;
+    config?: Config;
+    port?: number;
 }
 /**
  * RunningEngineRef is one engine the detector confirmed live: the engine id,

package/packages/core/lib/status.js

@@ -28,7 +28,12 @@ export function isGpuBusy(usage) {
 export function computeProviderStatuses(input) {
     const statuses = {};
     for (const provider of input.providers) {
-        const matches = input.running.filter((ref) => ref.engineId === provider.engine);
+        // A provider that names a port only counts an engine running on that
+        // port: two configs of one engine on different ports are distinct
+        // engines, and a match on the other port must not confirm (or deny) this
+        // config's model. An unnamed port keeps the engine-wide match.
+        const matches = input.running.filter((ref) => ref.engineId === provider.engine &&
+            (provider.port === undefined || ref.port === undefined || ref.port === provider.port));
         if (matches.length > 0) {
             // The engine is running. The question is which model it serves: the
             // detector's identified model, if it tied one, else unknown.

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-core",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Pure, framework-free domain model for the dsh local-inference plugin: ParameterSpec, HardwareProfile, EngineAdapter, VramEstimator, GuidelineEngine, DefaultsResolver, DshModelRegistrar, and SystemDepProvisioner primitives shared by every engine and model",
   "keywords": [
     "dsh",