dsh-plugin-local-infer 0.1.0 → 0.1.2

package/packages/service/lib/index.js

@@ -15,7 +15,7 @@
  * Phase 6 over the dsh settings seam, and `resolveDefaults` and
  * `fetchPreset` by Phase 7 over the core defaults resolver and the
  * mod-search bridge.
- * @module @dsh/dsh-plugin-local-infer/service
+ * @module dsh-plugin-local-infer/service
  */
 import { exec, execFile, spawn } from 'node:child_process';
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
@@ -46,6 +46,14 @@ export class LocalInferError extends Error {
  * "not available" instead.
  */
 const PROBE_TIMEOUT_MS = 5000;
+/**
+ * The adopted-process poll interval. A re-adopted engine (a surviving process
+ * with no ChildProcess after a DSH restart) is watched for death through a
+ * liveness probe on this cadence: fast enough that a pkill settles the
+ * provider's state within seconds, slow enough that a signal-0 send per
+ * watched engine is free.
+ */
+const PROCESS_WATCH_MS = 5000;
 /**
  * `ctx.localInfer`. Holds the engine, preset, guideline, and VramModel
  * reservations; the registries are read per call so a provider that unloads
@@ -72,6 +80,25 @@ export class LocalInfer extends Service {
     // restart, so a fresh start tracks only the launches it made itself. See
     // PLAN.md for the PID-cache note: a full PID cache is a future refinement.
     launchedModels = new Map();
+    // The live ports tracked per launched engine (launches and adopted re-links
+    // both register). The death handler clears the engine's plugin-launched flag
+    // only when its last live port dies, so one provider's engine stopping does
+    // not un-flag a second provider's still-running engine on another port.
+    launchedPorts = new Map();
+    // The poll watchers for processes adopted from stored launch records: a
+    // re-adopted engine has no ChildProcess to listen on after a DSH restart, so
+    // a liveness poll stands in for the exit event. Keyed by port; the timers
+    // are unref'd so a watched engine never keeps the host or a test alive.
+    engineWatchers = new Map();
+    // The pids whose death this process already watches through a live child
+    // handle. A summary re-link that adopts this DSH's own launch record must
+    // not stack a poll watcher on top of the handle's close event.
+    handledPids = new Set();
+    // The route-registered hook for engine process deaths (a crash, a pkill, or
+    // a poll-detected death of an adopted process). The observer persists the
+    // provider entry's cleared state; a headless profile registers none and the
+    // service still settles its own live state.
+    deathObserver;
     constructor(ctx) {
         super(ctx, 'localInfer');
     }
@@ -267,47 +294,65 @@ export class LocalInfer extends Service {
     }
     /**
      * providerStatuses resolves the running-state the card paints each saved
-     * provider's status dot from. It collects every registered adapter's launch
-     * signature, probes the running process table against those markers, and
-     * ties a running engine's port to the model the plugin launched it with (the
-     * launched-models map), so a plugin-launched engine reads as that model and
-     * a foreign engine reads as "engine running, model unknown". The GPU-usage
-     * reading feeds the busy-card rule. The answer is the core resolver's: a
-     * busy card or no engine running reads as unsure for every provider, an
-     * engine the detector saw but could not tie to a model reads as unsure for
-     * its configs and stopped for the rest, and a confirmed engine-plus-model
-     * reads as running. The options inject the probe results, so a test prices a
-     * busy card or a foreign engine without a live nvidia-smi or ps.
+     * provider's status dot from. It prices each provider's own launch signature
+     * through the registered adapter (the build mode's binary, the port the
+     * provider's config binds, the env keys), so an engine the plugin launched
+     * on a non-default port matches its config instead of reading forever as a
+     * process no signature covers, and ties the matched port to the model the
+     * plugin launched it with (the launched-models map). The GPU-usage reading
+     * feeds the busy-card rule. The answer is the core resolver's: a busy card
+     * or no engine running reads as unsure for every provider, an engine the
+     * detector saw but could not tie to a model reads as unsure for its configs
+     * and stopped for the rest, and a confirmed engine-plus-model reads as
+     * running. The options inject the probe results, so a test prices a busy
+     * card or a foreign engine without a live nvidia-smi or ps.
      */
     async providerStatuses(providers, options) {
-        const refs = [];
-        for (const adapter of this.engineRegistry.values()) {
-            const signature = adapter.launchSignature?.();
-            if (signature !== undefined) {
-                refs.push({ engineId: adapter.id, signature });
+        const signatures = providers.map((provider) => {
+            const adapter = this.engineRegistry.get(provider.engine);
+            return adapter?.launchSignature?.(provider.config ?? {});
+        });
+        const markers = [];
+        for (const signature of signatures) {
+            if (signature !== undefined && !markers.includes(signature.binary)) {
+                markers.push(signature.binary);
             }
         }
-        const markers = refs.map((ref) => ref.signature.binary);
         const processes = options?.processes !== undefined ? options.processes : await probeProcesses(markers);
         const running = [];
-        for (const ref of refs) {
-            const match = processes.find((line) => matchLaunchSignature(line, ref.signature));
+        const pricedSignatures = new Set();
+        for (const [index, provider] of providers.entries()) {
+            const signature = signatures[index];
+            if (signature === undefined)
+                continue;
+            // Two providers sharing one (binary, port) signature price one probe:
+            // the first provider's running entry answers for both.
+            const signatureKey = `${signature.binary}|${signature.port ?? ''}`;
+            if (pricedSignatures.has(signatureKey))
+                continue;
+            pricedSignatures.add(signatureKey);
+            const match = processes.find((line) => matchLaunchSignature(line, signature));
             if (match === undefined)
                 continue;
-            const entry = {
-                engineId: ref.engineId,
-                ...(ref.signature.port !== undefined ? { port: ref.signature.port } : {}),
-            };
-            if (ref.signature.port !== undefined) {
-                const launched = this.launchedModels.get(ref.signature.port);
-                if (launched !== undefined && launched.engineId === ref.engineId) {
+            const entry = { engineId: provider.engine };
+            if (signature.port !== undefined) {
+                entry.port = signature.port;
+                const launched = this.launchedModels.get(signature.port);
+                if (launched !== undefined && launched.engineId === provider.engine) {
                     entry.modelId = launched.modelId;
                 }
             }
             running.push(entry);
         }
         const gpuUsage = options?.gpuUsage !== undefined ? options.gpuUsage : await probeGpuUsage();
-        return computeProviderStatuses({ providers, running, gpuBusy: isGpuBusy(gpuUsage) });
+        // The provider's resolved port rides into the resolver so two configs of
+        // one engine on different ports confirm only against the engine running
+        // on their own port.
+        const priced = providers.map((provider, index) => {
+            const port = signatures[index]?.port;
+            return port !== undefined ? { ...provider, port } : provider;
+        });
+        return computeProviderStatuses({ providers: priced, running, gpuBusy: isGpuBusy(gpuUsage) });
     }
     /**
      * unsureBannerKillCommands returns the bash kill commands for the engine
@@ -411,13 +456,34 @@ export class LocalInfer extends Service {
             throw new LocalInferError(`no engine adapter is registered for "${plan.engineId}"`, 'LOCAL_INFER_INVALID_ENGINE');
         }
         const platform = this.platformConfigRegistry.get(plan.engineId);
-        const deployResult = await adapter.deploy(plan, platform);
+        // The deploy step reports its download and build sub-steps through the
+        // progress sink, so the card's button reads the phase that is running.
+        const onProgress = options?.onProgress;
+        // The trust gate and the auto-rebuild flag ride into the deploy step,
+        // which reads them to decide whether a rebuild's missing-binary symlink
+        // runs (gate on) or is written to the card's Logs section (off), and
+        // whether the git sync (fetch, rebase, rebuild) runs at all.
+        // exactOptionalPropertyTypes: only pass the option object when a key is
+        // present.
+        const hasDeployOptions = options?.allowRunDeps !== undefined || options?.autoRebuild !== undefined;
+        const deployOptions = hasDeployOptions
+            ? {
+                ...(options?.allowRunDeps !== undefined ? { allowRunDeps: options.allowRunDeps } : {}),
+                ...(options?.autoRebuild !== undefined ? { autoRebuild: options.autoRebuild } : {}),
+            }
+            : undefined;
+        const deployResult = await adapter.deploy(plan, platform, onProgress, deployOptions);
         if (!deployResult.ok) {
             // exactOptionalPropertyTypes: only write the detail key when it is present.
             const result = { plan, healthy: false };
             if (deployResult.detail !== undefined) {
                 result.detail = deployResult.detail;
             }
+            // A failed deploy still carries the build decision and output it captured,
+            // so the card's Logs section shows the step that broke.
+            if (deployResult.logs !== undefined && deployResult.logs !== '') {
+                result.logs = deployResult.logs;
+            }
             return result;
         }
         // A successful deploy means the engine process is running, so the
@@ -425,12 +491,31 @@ export class LocalInfer extends Service {
         // already priced by the estimator, and pricing the GPU's used VRAM on
         // top would double-count.
         this.launchedEngines.add(plan.engineId);
+        if (plan.port !== undefined) {
+            // A fresh launch on a port replaces any adopted-process watcher left
+            // over from the engine this launch displaced on that port.
+            this.stopEngineWatcher(plan.port);
+            const ports = this.launchedPorts.get(plan.engineId) ?? new Set();
+            ports.add(plan.port);
+            this.launchedPorts.set(plan.engineId, ports);
+        }
         // The provider-status detector ties a running engine's port to the model
         // the plugin launched it with, so a live engine the plugin started reads
         // as that model (green) rather than "engine running, model unknown".
         if (plan.modelId !== undefined && plan.port !== undefined) {
             this.launchedModels.set(plan.port, { engineId: plan.engineId, modelId: plan.modelId });
         }
+        // The exit watch attaches before the health poll, so an engine that
+        // crashes mid-startup (or is pkill'd during the poll) settles the live
+        // state and reaches the death observer instead of leaving the port tied
+        // to a model that is no longer serving.
+        if (deployResult.handle !== undefined) {
+            this.watchLaunchedHandle(deployResult.handle, plan);
+        }
+        // The health poll is the launch phase: the rebuild (download, build) is
+        // done and the engine process is up, so the card's button reads
+        // "Launching..." while it waits for the engine to report ready.
+        onProgress?.('launch');
         const health = await adapter.healthCheck(plan, options);
         const launchResult = { plan, healthy: health.healthy };
         if (health.detail !== undefined) {
@@ -449,10 +534,16 @@ export class LocalInfer extends Service {
             }
         }
         // Read the engine's captured output after the health poll, so the result
-        // carries the log lines the engine printed while it came up. The route
-        // persists these as the last run and writes them to the configured file.
-        const handleLogs = deployResult.handle?.logs;
-        if (handleLogs !== undefined && handleLogs !== '') {
+        // carries the log lines the engine printed while it came up. The deploy
+        // step's own captured output (the rebuild decision, the build command, and
+        // its output) is kept separate in buildLogs, so the route orders the launch
+        // command after a build (or a direct launch) and before the engine output.
+        const buildLogs = deployResult.logs ?? '';
+        const handleLogs = deployResult.handle?.logs ?? '';
+        if (buildLogs !== '') {
+            launchResult.buildLogs = buildLogs;
+        }
+        if (handleLogs !== '') {
             launchResult.logs = handleLogs;
         }
         return launchResult;
@@ -489,16 +580,138 @@ export class LocalInfer extends Service {
                 // resolver keeps its 3 GiB default and the provider-status detector
                 // ties its port to the model the record names.
                 this.launchedEngines.add(entry.record.engineId);
-                if (entry.record.port !== undefined && entry.record.modelId !== undefined) {
-                    this.launchedModels.set(entry.record.port, {
-                        engineId: entry.record.engineId,
-                        modelId: entry.record.modelId,
-                    });
+                if (entry.record.port !== undefined) {
+                    const ports = this.launchedPorts.get(entry.record.engineId) ?? new Set();
+                    ports.add(entry.record.port);
+                    this.launchedPorts.set(entry.record.engineId, ports);
+                    if (entry.record.modelId !== undefined) {
+                        this.launchedModels.set(entry.record.port, {
+                            engineId: entry.record.engineId,
+                            modelId: entry.record.modelId,
+                        });
+                    }
+                    // Re-attach the exit watch the restart dropped: the adopted child
+                    // has no ChildProcess to listen on, so the poll stands in and the
+                    // death settles the state the same way a live child's close event
+                    // does. A repeat summary call keeps the existing watcher.
+                    this.watchAdoptedEngine(entry.record, processAlive);
                 }
             }
         }
         return outcomes;
     }
+    /**
+     * setEngineDeathObserver registers the route's hook for engine process
+     * deaths: a crash or pkill seen through a launched handle's exit event, or a
+     * poll-detected death of a process adopted from a stored launch record. The
+     * observer persists the provider entry's cleared state so the card reads the
+     * provider stopped instead of carrying a stale record. Passing undefined
+     * clears it, which the route's effect does on dispose.
+     */
+    setEngineDeathObserver(observer) {
+        this.deathObserver = observer;
+    }
+    /**
+     * watchLaunchedHandle ties a launched child's one-shot exit to the live
+     * state: the host's close/error event (a crash, a pkill, or the stop kill)
+     * reports through observeEngineDeath. A handle whose host cannot watch (no
+     * onExit, a stub) is left to the re-link rule to price after a restart.
+     */
+    watchLaunchedHandle(handle, plan) {
+        if (typeof handle.onExit !== 'function')
+            return;
+        if (handle.pid > 0) {
+            this.handledPids.add(handle.pid);
+        }
+        handle.onExit((exit) => {
+            this.handledPids.delete(handle.pid);
+            this.observeEngineDeath({
+                engineId: plan.engineId,
+                ...(plan.port !== undefined ? { port: plan.port } : {}),
+                ...(plan.modelId !== undefined ? { modelId: plan.modelId } : {}),
+                ...(handle.pid > 0 ? { pid: handle.pid } : {}),
+                code: exit.code,
+                signal: exit.signal,
+                ...(exit.error !== undefined ? { detail: exit.error } : {}),
+            });
+        });
+    }
+    /**
+     * watchAdoptedEngine re-attaches the exit watch for a process this DSH did
+     * not spawn: a surviving engine adopted from a stored launch record has no
+     * ChildProcess to listen on after a restart, so an unref'd poll on the
+     * liveness probe stands in for the exit event. When the pid dies the watcher
+     * stops itself and reports through observeEngineDeath, so the provider's
+     * state settles without waiting for the next summary re-link to price the
+     * record dead.
+     */
+    watchAdoptedEngine(record, processAlive) {
+        if (record.port === undefined)
+            return;
+        if (this.engineWatchers.has(record.port))
+            return;
+        // A launch this DSH made itself already has the child handle's close
+        // event; a poll watcher would only double-report the same death.
+        if (this.handledPids.has(record.pid))
+            return;
+        const port = record.port;
+        const timer = setInterval(() => {
+            if (processAlive(record.pid))
+                return;
+            this.observeEngineDeath({
+                engineId: record.engineId,
+                port,
+                ...(record.modelId !== undefined ? { modelId: record.modelId } : {}),
+                pid: record.pid,
+                code: null,
+                signal: null,
+                detail: 'the adopted engine process exited outside this DSH session',
+            });
+        }, PROCESS_WATCH_MS);
+        timer.unref();
+        this.engineWatchers.set(port, { pid: record.pid, timer });
+    }
+    /**
+     * stopEngineWatcher cancels one port's adopted-process poll, if it has one.
+     */
+    stopEngineWatcher(port) {
+        const watcher = this.engineWatchers.get(port);
+        if (watcher === undefined)
+            return;
+        clearInterval(watcher.timer);
+        this.engineWatchers.delete(port);
+    }
+    /**
+     * observeEngineDeath settles one engine process's death against the live
+     * state: the port-to-model tie drops when the dead engine still owns the
+     * port, the port leaves the engine's live ledger, the plugin-launched flag
+     * clears with the engine's last live port, the adopted-process watcher for
+     * the port stops, and the registered death observer (the route's persistence
+     * hook) receives the event. The launch record itself is the route's: the
+     * observer clears the provider entry's record so the card reads the provider
+     * stopped, not stale.
+     */
+    observeEngineDeath(event) {
+        if (event.port !== undefined) {
+            const tracked = this.launchedModels.get(event.port);
+            if (tracked !== undefined && tracked.engineId === event.engineId) {
+                this.launchedModels.delete(event.port);
+            }
+            this.stopEngineWatcher(event.port);
+            const ports = this.launchedPorts.get(event.engineId);
+            if (ports !== undefined) {
+                ports.delete(event.port);
+                if (ports.size === 0) {
+                    this.launchedPorts.delete(event.engineId);
+                }
+            }
+        }
+        const remaining = event.port !== undefined ? this.launchedPorts.get(event.engineId) : undefined;
+        if (remaining === undefined || remaining.size === 0) {
+            this.launchedEngines.delete(event.engineId);
+        }
+        this.deathObserver?.(event);
+    }
     /**
      * stop signals the engine a launch started: it resolves the adapter by the
      * plan's engineId and runs the adapter's stop step (kill the tracked process,
@@ -510,14 +723,31 @@ export class LocalInfer extends Service {
             throw new LocalInferError(`no engine adapter is registered for "${plan.engineId}"`, 'LOCAL_INFER_INVALID_ENGINE');
         }
         await adapter.stop(plan);
-        // The stop step signalled the tracked process or container, so the
-        // engine is no longer plugin-launched and the OS-reserve resolver may
-        // price the card's live usage for it again.
-        this.launchedEngines.delete(plan.engineId);
         // Clear the port-to-model entry too, so the provider-status detector no
-        // longer ties this port to the model the plugin launched it with.
+        // longer ties this port to the model the plugin launched it with, and
+        // cancel any adopted-process watcher standing on the port.
         if (plan.port !== undefined) {
             this.launchedModels.delete(plan.port);
+            this.stopEngineWatcher(plan.port);
+            const ports = this.launchedPorts.get(plan.engineId);
+            if (ports !== undefined) {
+                ports.delete(plan.port);
+                if (ports.size === 0) {
+                    this.launchedPorts.delete(plan.engineId);
+                }
+            }
+            // The engine is no longer plugin-launched only when it has no other
+            // live port: a second provider's engine on another port keeps the
+            // OS-reserve default.
+            const remaining = this.launchedPorts.get(plan.engineId);
+            if (remaining === undefined || remaining.size === 0) {
+                this.launchedEngines.delete(plan.engineId);
+            }
+        }
+        else {
+            // A plan with no port (a compose profile the stop step signalled down)
+            // clears the flag outright.
+            this.launchedEngines.delete(plan.engineId);
         }
     }
     /**
@@ -1025,6 +1255,12 @@ const shellRunCommand = (command) => new Promise(resolve => {
     };
     child.stdout.on('data', append);
     child.stderr.on('data', append);
+    // Without a listener, a child that fails to start (a missing shell) emits
+    // an unlistened 'error' and throws it as an uncaughtException through the
+    // host. Read it as a failed command instead.
+    child.on('error', (error) => {
+        resolve({ ok: false, detail: error.message });
+    });
     child.on('close', code => {
         if (code === 0) {
             resolve({ ok: true });

package/packages/service/lib/types.d.ts

@@ -1,4 +1,4 @@
-import type { CommandOutcome, Config, DefaultModel, ModelDirectoryEntry, EngineAdapter, EngineDepPlan, EnginePlatformConfig, Guideline, GuidelineResult, GpuUsageProbe, HardwareProfile, InstallResult, LaunchPlan, ModelRow, Preset, PresetSource, ProcessLine, ProviderLaunchRecord, ProviderRef, ProviderStatus, ReLinkOutcome, RegisterResult, ReserveResolution, ReserveSource, ResolvedDefaults, SettingsOp, SystemDep, VramBreakdown, VramModel, VramVerdict } from '@dsh/dsh-plugin-local-infer/core';
+import type { CommandOutcome, Config, DefaultModel, ModelDirectoryEntry, EngineAdapter, EngineDepPlan, EnginePlatformConfig, Guideline, GuidelineResult, GpuUsageProbe, HardwareProfile, InstallResult, LaunchPlan, LaunchProgress, ModelRow, Preset, PresetSource, ProcessLine, ProviderLaunchRecord, ProviderRef, ProviderStatus, ReLinkOutcome, RegisterResult, ReserveResolution, ReserveSource, ResolvedDefaults, SettingsOp, SystemDep, VramBreakdown, VramModel, VramVerdict } from 'dsh-plugin-local-infer/core';
 /**
  * EstimateResult is the answer to an estimate call: the full VRAM breakdown,
  * the one-word verdict the meter renders, the source the numbers came from,
@@ -37,6 +37,24 @@ export interface ProviderStatusOptions {
     processes?: ProcessLine[];
     gpuUsage?: GpuUsageProbe | null;
 }
+/**
+ * EngineDeathEvent is the one-shot report that an engine process the plugin
+ * tracked has ended: an observed crash or pkill (the exit code and signal from
+ * a live child's close event, or a spawn error detail for a child that never
+ * ran), or a poll-detected death of a process adopted from a stored launch
+ * record after a DSH restart (a null code and signal with a detail). The route
+ * registers the observer that persists the provider entry's cleared state, so
+ * the card reads the provider stopped instead of carrying a stale record.
+ */
+export interface EngineDeathEvent {
+    engineId: string;
+    port?: number;
+    modelId?: string;
+    pid?: number;
+    code: number | null;
+    signal: string | null;
+    detail?: string;
+}
 /**
  * LaunchResult is the answer to a launch call: the plan that was started,
  * whether the health check passed, a detail for the UI, and the engine's
@@ -47,13 +65,18 @@ export interface ProviderStatusOptions {
  * deploy pulls an image only), and `parentPid` is the DSH process pid that
  * launched the engine (absent when the host process did not identify as
  * DSH), the two fields the route persists as the provider entry's launch
- * record for the restart re-link.
+ * record for the restart re-link. `buildLogs` is the deploy step's own
+ * captured output (the rebuild decision, the build command, and its output)
+ * kept separate from the engine's runtime `logs`, so the route can order the
+ * launch command after a build (or after a direct launch) and before the
+ * engine output.
  */
 export interface LaunchResult {
     plan: LaunchPlan;
     healthy: boolean;
     detail?: string;
     logs?: string;
+    buildLogs?: string;
     pid?: number;
     parentPid?: number;
 }
@@ -61,10 +84,22 @@ export interface LaunchResult {
  * LaunchOptions tunes the launch health poll: the interval between attempts
  * and the attempt cap. The service passes the config's healthPollMs and
  * healthMaxAttempts through; an absent option keeps the adapter's default.
+ * `onProgress`, when present, is called as each launch phase (the deploy
+ * sub-steps and the health poll) begins, so the card's Launch control reads
+ * the phase that is actually running. `allowRunDeps` is the Play/Run trust gate
+ * (the card's "Allow one-click install (sudo)" checkbox) the deploy step reads
+ * to decide whether a rebuild's missing-binary symlink into /usr/local/bin runs
+ * (on) or is written to the card's Logs section (off). `autoRebuild` is the
+ * card's "Auto Rebuild" checkbox: when false, the deploy step skips the git
+ * sync (fetch, rebase, rebuild) and launches the checkout as-is. Absent reads
+ * as true (the rebuild runs).
  */
 export interface LaunchOptions {
     pollMs?: number;
     maxAttempts?: number;
+    onProgress?: LaunchProgress;
+    allowRunDeps?: boolean;
+    autoRebuild?: boolean;
 }
 /**
  * RegisterModelOptions tunes the model registration: agentDefault points the
@@ -216,6 +251,13 @@ export interface LocalInferService {
         processAlive?: (pid: number) => boolean;
         commandLine?: (pid: number) => string | undefined;
     }): Promise<Record<string, ReLinkOutcome>>;
+    /**
+     * setEngineDeathObserver registers the callback the route uses to persist a
+     * provider entry's cleared state when its engine process dies (a crash, a
+     * pkill, or a poll-detected death of an adopted process). Passing undefined
+     * clears it, which the route's effect does on dispose.
+     */
+    setEngineDeathObserver(observer: ((event: EngineDeathEvent) => void) | undefined): void;
     registerModel(plan: LaunchPlan, model: ModelRow, options?: RegisterModelOptions): Promise<RegisterResult>;
     removeModel(providerId: string, modelId: string): Promise<void>;
     resolveDefaults(engineId: string, modelId: string, hw: HardwareProfile, explicit?: Config): Promise<ResolvedDefaults>;

package/packages/service/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@dsh/dsh-plugin-local-infer-service",
+  "name": "dsh-plugin-local-infer-service",
   "version": "0.1.0",
   "description": "Service Definition for the dsh local-inference capability seam (ctx.localInfer): the engine, preset, and guideline registries plus the orchestration entry points (estimate, guidelines, deps, installString, runInstall, launch, registerModel). Carries no store of its own.",
   "keywords": [
@@ -30,7 +30,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@dsh/dsh-plugin-local-infer-core": "workspace:^"
+    "dsh-plugin-local-infer-core": "workspace:^"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1"

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

@@ -8,7 +8,7 @@
  * In the scaffold this plugin is a no-op placeholder that injects the seam so
  * the bundle loads with zero tools. Phase 8 registers the four tools and the
  * prompt section.
- * @module @dsh/dsh-plugin-local-infer/tool
+ * @module dsh-plugin-local-infer/tool
  */
 import type { Context } from '@deepseek-ai/cordis';
 export declare const name = "local-infer-tool";

package/packages/tool/lib/index.js

@@ -8,7 +8,7 @@
  * In the scaffold this plugin is a no-op placeholder that injects the seam so
  * the bundle loads with zero tools. Phase 8 registers the four tools and the
  * prompt section.
- * @module @dsh/dsh-plugin-local-infer/tool
+ * @module dsh-plugin-local-infer/tool
  */
 export const name = 'local-infer-tool';
 export const inject = ['localInfer'];

package/packages/tool/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@dsh/dsh-plugin-local-infer-tool",
+  "name": "dsh-plugin-local-infer-tool",
   "version": "0.1.0",
   "description": "Model-facing tools for the dsh local-inference plugin: local_infer_estimate, local_infer_launch, local_infer_status, and local_infer_register, each on its own timeout budget, plus the system-prompt section that tells the agent when to use them",
   "keywords": [
@@ -29,8 +29,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@dsh/dsh-plugin-local-infer-core": "workspace:^",
-    "@dsh/dsh-plugin-local-infer-service": "workspace:^"
+    "dsh-plugin-local-infer-core": "workspace:^",
+    "dsh-plugin-local-infer-service": "workspace:^"
   },
   "peerDependencies": {
     "@deepseek-ai/cordis": ">=4.0.1"

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

@@ -5,9 +5,9 @@
  * "Get" gate the plan names (disabled until every dep reports satisfied).
  * The model is pure data the card draws, so the mapping stays unit-testable
  * here.
- * @module @dsh/dsh-plugin-local-infer/ui/deps
+ * @module dsh-plugin-local-infer/ui/deps
  */
-import type { DepCheck, DepStatus } from '@dsh/dsh-plugin-local-infer/core';
+import type { DepCheck, DepStatus } from 'dsh-plugin-local-infer/core';
 /**
  * DepItemModel is one row of the panel's dep list: the dep id, the purpose
  * the user reads, the current status, and whether installing it needs sudo.

package/packages/ui/lib/deps.js

@@ -5,7 +5,7 @@
  * "Get" gate the plan names (disabled until every dep reports satisfied).
  * The model is pure data the card draws, so the mapping stays unit-testable
  * here.
- * @module @dsh/dsh-plugin-local-infer/ui/deps
+ * @module dsh-plugin-local-infer/ui/deps
  */
 /**
  * renderDeps maps the checkDeps results and the rendered install string to

package/packages/ui/lib/form.d.ts

@@ -3,9 +3,9 @@
  * `group`, and a field per `ParameterSpec`. The model is pure data, so the
  * panel (Phase 8) renders it without touching the domain model, and the
  * mapping from `form` kind to control kind stays unit-testable here.
- * @module @dsh/dsh-plugin-local-infer/ui/form
+ * @module dsh-plugin-local-infer/ui/form
  */
-import type { ComboOption, Config, EnumOption, HardwareProfile, ParameterForm, ParameterSpec } from '@dsh/dsh-plugin-local-infer/core';
+import type { ComboOption, Config, EnumOption, HardwareProfile, ParameterForm, ParameterSpec } from 'dsh-plugin-local-infer/core';
 /**
  * The control kinds the panel switches on: checkbox, dropdown, slider plus
  * number input, text, a directory/file picker, and a dropdown plus free-text

package/packages/ui/lib/form.js

@@ -3,7 +3,7 @@
  * `group`, and a field per `ParameterSpec`. The model is pure data, so the
  * panel (Phase 8) renders it without touching the domain model, and the
  * mapping from `form` kind to control kind stays unit-testable here.
- * @module @dsh/dsh-plugin-local-infer/ui/form
+ * @module dsh-plugin-local-infer/ui/form
  */
 /**
  * The group label a spec without a `group` renders under.

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

@@ -7,7 +7,7 @@
  *
  * The render models (form, meter, warnings) are pure data the panel draws
  * from; Phase 8 wires them into one panel with the lifecycle controls.
- * @module @dsh/dsh-plugin-local-infer/ui
+ * @module dsh-plugin-local-infer/ui
  */
 import type { Context } from '@deepseek-ai/cordis';
 export declare const name = "local-infer-ui";

package/packages/ui/lib/index.js

@@ -7,7 +7,7 @@
  *
  * The render models (form, meter, warnings) are pure data the panel draws
  * from; Phase 8 wires them into one panel with the lifecycle controls.
- * @module @dsh/dsh-plugin-local-infer/ui
+ * @module dsh-plugin-local-infer/ui
  */
 import { registerLocalInferRoute } from "./route.js";
 export const name = 'local-infer-ui';

package/packages/ui/lib/meter.d.ts

@@ -6,9 +6,9 @@
  * as authoritative. The model is pure data, so the panel (Phase 8) renders
  * it without touching the domain model, and the mapping stays unit-testable
  * here.
- * @module @dsh/dsh-plugin-local-infer/ui/meter
+ * @module dsh-plugin-local-infer/ui/meter
  */
-import type { ReserveSource, VramBreakdown, VramVerdict } from '@dsh/dsh-plugin-local-infer/core';
+import type { ReserveSource, VramBreakdown, VramVerdict } from 'dsh-plugin-local-infer/core';
 /**
  * MeterSegment is one segment of the to-scale bar. `percent` is the share of
  * the full card the segment occupies, so the bar reads against the card the