@dsh-workbench/shared 0.3.11 → 1.0.0-beta.0

package/dist/host/shell-text.d.ts

@@ -1,7 +1,14 @@
 /**
- * 把一个值裹成 shell 里的单引号字面量（值里的单引号一并转义），保证元字符按字面量传递。
+ * 按目标平台把一个值裹成 shell 字面量：POSIX 用单引号，win32 用双引号（cmd 与 PowerShell 都认）。
  * @param value - 任意值；不是字符串的先 `String()`。
- * @returns 可安全拼进 `/bin/sh -c` 的一段文本 —— 含空格 / `$()` / `;` / 通配符的值都不会被当成语法。
+ * @param platform - 目标平台，默认当前 `process.platform`。
+ * @returns 可安全拼进该平台 shell 命令的一段文本；含空格 / 元字符的值不会被当成语法。
+ */
+export declare function quoteShellArgFor(value: unknown, platform?: NodeJS.Platform): string;
+/**
+ * 按当前平台把值裹成 shell 字面量；跨平台代码要固定平台时用 `quoteShellArgFor`。
+ * @param value - 任意值；不是字符串的先 `String()`。
+ * @returns 可安全拼进当前平台 shell 命令的一段文本。
  */
 export declare function quoteShellArg(value: unknown): string;
 /**

package/dist/host/shell-text.js

@@ -1,10 +1,22 @@
 /**
- * 把一个值裹成 shell 里的单引号字面量（值里的单引号一并转义），保证元字符按字面量传递。
+ * 按目标平台把一个值裹成 shell 字面量：POSIX 用单引号，win32 用双引号（cmd 与 PowerShell 都认）。
  * @param value - 任意值；不是字符串的先 `String()`。
- * @returns 可安全拼进 `/bin/sh -c` 的一段文本 —— 含空格 / `$()` / `;` / 通配符的值都不会被当成语法。
+ * @param platform - 目标平台，默认当前 `process.platform`。
+ * @returns 可安全拼进该平台 shell 命令的一段文本；含空格 / 元字符的值不会被当成语法。
+ */
+export function quoteShellArgFor(value, platform = process.platform) {
+    const text = String(value);
+    if (platform === 'win32')
+        return `"${text.replace(/"/g, '\\"')}"`;
+    return `'${text.replace(/'/g, `'\\''`)}'`;
+}
+/**
+ * 按当前平台把值裹成 shell 字面量；跨平台代码要固定平台时用 `quoteShellArgFor`。
+ * @param value - 任意值；不是字符串的先 `String()`。
+ * @returns 可安全拼进当前平台 shell 命令的一段文本。
  */
 export function quoteShellArg(value) {
-    return `'${String(value).replace(/'/g, `'\\''`)}'`;
+    return quoteShellArgFor(value, process.platform);
 }
 /**
  * 取一段文本的末尾若干行（如命令输出），顺带去掉首尾空白。

package/dist/host/shell.d.ts

@@ -12,3 +12,5 @@ export declare function runShell(shell: DshShell, command: string, options?: {
     timeoutMs?: number;
     signal?: AbortSignal;
 }): Promise<ShellResult>;
+export declare function backgroundPrefix(): readonly string[];
+export declare function backgroundLine(command: string, argv: readonly string[]): string;

package/dist/host/shell.js

@@ -1,4 +1,5 @@
 import { GIT_TIMEOUT_MS } from '../config/constants.js';
+import { quoteShellArg } from './shell-text.js';
 const DEFAULT_MAX_BYTES = 8 * 1024 * 1024;
 export async function runShell(shell, command, options = {}) {
     const { workdir, timeoutMs = GIT_TIMEOUT_MS, signal } = options;
@@ -21,3 +22,9 @@ export async function runShell(shell, command, options = {}) {
         truncated: result.stdout.truncated || result.stderr.truncated,
     };
 }
+export function backgroundPrefix() {
+    return [quoteShellArg('env'), quoteShellArg('OPENCLI_WINDOW=background')];
+}
+export function backgroundLine(command, argv) {
+    return [...backgroundPrefix(), quoteShellArg(command), ...argv.map(quoteShellArg)].join(' ');
+}

package/dist/host/spec.d.ts

@@ -0,0 +1,8 @@
+export interface NpmRef {
+    readonly name: string;
+    readonly version?: string;
+}
+export declare function isPackageName(value: string): boolean;
+export declare function splitNpmSpec(spec: string): NpmRef | undefined;
+export declare function localDirOf(spec: string): string | undefined;
+export declare function refusalReason(): string;

package/dist/host/spec.js

@@ -0,0 +1,24 @@
+import path from 'node:path';
+const PACKAGE_NAME = /^(?:@[a-z0-9][a-z0-9._~-]*\/)?[a-z0-9][a-z0-9._~-]*$/;
+const VERSION = /^[a-zA-Z0-9][a-zA-Z0-9._+-]*$/;
+export function isPackageName(value) {
+    return value.length <= 214 && PACKAGE_NAME.test(value);
+}
+export function splitNpmSpec(spec) {
+    const value = spec.trim();
+    const at = value.lastIndexOf('@');
+    const name = at > 0 ? value.slice(0, at) : value;
+    const version = at > 0 ? value.slice(at + 1) : '';
+    if (!isPackageName(name))
+        return undefined;
+    if (version !== '' && !VERSION.test(version))
+        return undefined;
+    return { name, ...(version === '' ? {} : { version }) };
+}
+export function localDirOf(spec) {
+    const dir = spec.trim().replace(/^(?:file|link):/, '');
+    return path.isAbsolute(dir) ? dir : undefined;
+}
+export function refusalReason() {
+    return '这个包既不是工作台的模块，也不是 opencli 的插件，装了也用不上';
+}

package/dist/host/supply-index.d.ts

@@ -0,0 +1,34 @@
+import type { Need, SupplySource } from '../contract/needs.js';
+export interface SupplyDeclaration {
+    readonly id: string;
+    readonly needs?: readonly Need[];
+}
+export interface SupplyEntry {
+    readonly key: string;
+    readonly kind: 'extension' | 'lib';
+    readonly names: readonly string[];
+    readonly package: string;
+    readonly runtime?: string;
+    readonly sources: readonly SupplySource[];
+    readonly declarers: readonly string[];
+    readonly commands: readonly string[];
+    readonly conflicted: boolean;
+}
+export interface SupplyConflict {
+    readonly kind: 'source-mismatch' | 'name-mismatch';
+    readonly key: string;
+    readonly names: readonly string[];
+    readonly declarers: readonly string[];
+    readonly detail: string;
+}
+export interface SupplyIndex {
+    readonly entries: ReadonlyMap<string, SupplyEntry>;
+    readonly conflicts: readonly SupplyConflict[];
+    readonly problems: readonly string[];
+    readonly entryOf: (kind: 'extension' | 'lib', name: string) => SupplyEntry | undefined;
+    readonly sourcesOf: (kind: 'extension' | 'lib', name: string) => readonly SupplySource[];
+}
+export declare function npmSourceOf(sources: readonly SupplySource[] | undefined): Extract<SupplySource, {
+    kind: 'npm';
+}> | undefined;
+export declare function buildSupplyIndex(declarations: readonly SupplyDeclaration[]): SupplyIndex;

package/dist/host/supply-index.js

@@ -0,0 +1,202 @@
+export function npmSourceOf(sources) {
+    return sources?.find((source) => source.kind === 'npm');
+}
+function text(value) {
+    return value === undefined ? '' : value.trim();
+}
+function conventionPackage(name) {
+    return `opencli-plugin-${name}`;
+}
+function nativeSourcePackage(source) {
+    if (source.kind === 'npm')
+        return text(source.package);
+    if (source.kind === 'git')
+        return `git:${text(source.url)}`;
+    return `local:${text(source.env) || text(source.path)}`;
+}
+function packageOf(need) {
+    if (need.kind === 'lib')
+        return text(need.name);
+    const first = need.sources?.[0];
+    if (first === undefined)
+        return conventionPackage(need.name);
+    if (first.kind === 'npm') {
+        const pkg = text(first.package);
+        return pkg === '' ? conventionPackage(need.name) : pkg;
+    }
+    return nativeSourcePackage(first);
+}
+function keyOf(kind, pkg) {
+    return `${kind}:${pkg}`;
+}
+function sourceCompatible(left, right) {
+    if (left.kind !== right.kind)
+        return false;
+    if (left.kind === 'npm' && right.kind === 'npm') {
+        if (text(left.package) !== '' && text(right.package) !== '' && text(left.package) !== text(right.package)) {
+            return false;
+        }
+        if (text(left.registryEnv) !== text(right.registryEnv))
+            return false;
+        const l = text(left.registryDefault);
+        const r = text(right.registryDefault);
+        return l === '' || r === '' || l === r;
+    }
+    if (left.kind === 'git' && right.kind === 'git')
+        return text(left.url) === text(right.url);
+    if (left.kind === 'local' && right.kind === 'local') {
+        return text(left.env) === text(right.env) && text(left.path) === text(right.path);
+    }
+    return false;
+}
+function sourcesCompatible(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((source, index) => {
+        const other = right[index];
+        return other !== undefined && sourceCompatible(source, other);
+    });
+}
+function mergedSource(left, right) {
+    if (left.kind === 'npm' && right.kind === 'npm') {
+        const pkg = text(left.package) === '' ? right.package : left.package;
+        const registryDefault = text(left.registryDefault) === '' ? right.registryDefault : left.registryDefault;
+        return {
+            ...left,
+            ...(pkg === undefined ? {} : { package: pkg }),
+            ...(registryDefault === undefined ? {} : { registryDefault }),
+        };
+    }
+    return left;
+}
+function mergeSources(entry, sources) {
+    if (!entry.declared) {
+        entry.declared = true;
+        entry.sources = [...sources];
+        return true;
+    }
+    if (!sourcesCompatible(entry.sources, sources)) {
+        entry.conflicted = true;
+        return false;
+    }
+    entry.sources = entry.sources.map((source, index) => {
+        const other = sources[index];
+        return other === undefined ? source : mergedSource(source, other);
+    });
+    return true;
+}
+function sourceText(source) {
+    if (source.kind === 'npm') {
+        return `${source.package === undefined ? '按包名约定' : source.package}（${source.registryEnv ?? '默认源'}）`;
+    }
+    if (source.kind === 'git')
+        return `git:${source.url}`;
+    return `local:${source.env ?? source.path ?? ''}`;
+}
+function addDeclarer(entry, unit, commands) {
+    if (!entry.declarers.includes(unit))
+        entry.declarers.push(unit);
+    for (const command of commands)
+        if (!entry.commands.includes(command))
+            entry.commands.push(command);
+}
+export function buildSupplyIndex(declarations) {
+    const entries = new Map();
+    const byName = new Map();
+    const conflicts = [];
+    const ensure = (kind, pkg) => {
+        const key = keyOf(kind, pkg);
+        const found = entries.get(key);
+        if (found !== undefined)
+            return found;
+        const created = {
+            key,
+            kind,
+            package: pkg,
+            declared: false,
+            names: [],
+            sources: [],
+            declarers: [],
+            commands: [],
+            conflicted: false,
+        };
+        entries.set(key, created);
+        return created;
+    };
+    for (const declaration of declarations) {
+        for (const need of declaration.needs ?? []) {
+            if (need.kind !== 'extension' && need.kind !== 'lib')
+                continue;
+            const pkg = packageOf(need);
+            const entry = ensure(need.kind, pkg);
+            if (!entry.names.includes(need.name))
+                entry.names.push(need.name);
+            if (need.kind === 'extension') {
+                entry.runtime = need.runtime;
+                addDeclarer(entry, declaration.id, need.commands ?? []);
+            }
+            else {
+                addDeclarer(entry, declaration.id, []);
+            }
+            const same = mergeSources(entry, need.sources ?? []);
+            if (!same) {
+                conflicts.push({
+                    kind: 'source-mismatch',
+                    key: entry.key,
+                    names: [...entry.names],
+                    declarers: [...entry.declarers],
+                    detail: `${entry.kind === 'extension' ? '插件' : '共用库'} ${entry.names.join('、')} 被 ` +
+                        `${entry.declarers.join('、')} 声明成了不同的来源（` +
+                        `${entry.sources.map(sourceText).join(' / ') || '无来源'}）`,
+                });
+            }
+            const nameKey = `${need.kind}:${need.name}`;
+            const seen = byName.get(nameKey);
+            if (seen !== undefined && seen.key !== entry.key) {
+                const detail = `${need.kind === 'extension' ? '插件' : '共用库'} ${need.name} 来自不同的包：` +
+                    `${seen.package} / ${entry.package}`;
+                entry.conflicted = true;
+                seen.conflicted = true;
+                conflicts.push({
+                    kind: 'name-mismatch',
+                    key: entry.key,
+                    names: [need.name],
+                    declarers: [...new Set([...seen.declarers, ...entry.declarers])],
+                    detail,
+                });
+            }
+            else if (seen === undefined) {
+                byName.set(nameKey, entry);
+            }
+        }
+    }
+    const deduped = new Map();
+    for (const conflict of conflicts) {
+        deduped.set(`${conflict.kind}:${conflict.key}`, conflict);
+    }
+    const frozenEntries = new Map();
+    for (const [key, entry] of entries) {
+        frozenEntries.set(key, {
+            key: entry.key,
+            kind: entry.kind,
+            names: [...entry.names],
+            package: entry.package,
+            ...(entry.runtime === undefined ? {} : { runtime: entry.runtime }),
+            sources: entry.sources.map((source) => ({ ...source })),
+            declarers: [...entry.declarers],
+            commands: [...entry.commands],
+            conflicted: entry.conflicted,
+        });
+    }
+    const entryOf = (kind, name) => byName.get(`${kind}:${name}`);
+    return {
+        entries: frozenEntries,
+        conflicts: [...deduped.values()],
+        problems: [...deduped.values()].map((conflict) => conflict.detail),
+        entryOf,
+        sourcesOf: (kind, name) => {
+            const entry = entryOf(kind, name);
+            return entry === undefined || entry.conflicted ? [] : entry.sources;
+        },
+    };
+}

package/dist/host/supply-port.d.ts

@@ -0,0 +1,5 @@
+import type { DshHostContext } from '../api/dsh.js';
+import type { SupplyPort } from './port-types.js';
+export type { SupplyPort } from './port-types.js';
+export declare function supplyPortOf(ctx: DshHostContext): SupplyPort;
+export declare function requireSupply(): SupplyPort;

package/dist/host/supply-port.js

@@ -0,0 +1,39 @@
+import { adaptersOf } from './adapters.js';
+export function supplyPortOf(ctx) {
+    const set = adaptersOf(ctx);
+    const env = set.supply;
+    const modules = set.modules;
+    return {
+        env,
+        modules,
+        resolvePluginSource: (source, environment, options) => env.resolvePluginSource(source, environment, options),
+        libInstallCommand: (options) => env.libInstallCommand(options),
+        pluginInstallPlan: (options) => env.pluginInstallPlan(options),
+        latestVersion: (options) => env.latestVersion(options),
+        missingReleaseParts: (options) => env.missingReleaseParts(options),
+        probeRelease: (options) => env.probeRelease(options),
+        splitNpmSpec: (spec) => env.splitNpmSpec(spec),
+        isolatedHome: () => modules.isolatedHome(),
+        cliCatalogPath: () => modules.cliCatalogPath(),
+        vendorPluginsDir: () => modules.vendorPluginsDir(),
+        opencliInstallCommand: () => modules.opencliInstallCommand(),
+        profileDirOf: (context) => modules.profileDirOf(context),
+        profileModules: (dir) => modules.profileModules(dir),
+        readInstalledModule: (dir, pkg) => modules.readInstalledModule(dir, pkg),
+        readProfilePackage: (dir, pkg) => modules.readProfilePackage(dir, pkg),
+        readBundleManager: (context) => modules.readBundleManager(context),
+        createRegistryNotebook: (dir) => modules.createRegistryNotebook(dir),
+        declarationGaps: (dir) => modules.declarationGaps(dir),
+        moduleDeclarationOf: (dir, pkg) => modules.moduleDeclarationOf(dir, pkg),
+        registryDeclarationOf: (options) => modules.registryDeclarationOf(options),
+        pathDeclarationOf: (spec) => modules.pathDeclarationOf(spec),
+        declarationRefusalOf: (name, raw) => modules.declarationRefusalOf(name, raw),
+        refusalReason: () => modules.refusalReason(),
+        packageRouteOf: (options) => modules.packageRouteOf(options),
+        isNewerVersion: (left, right) => modules.isNewerVersion(left, right),
+        startSelfUpdate: (request, onError) => modules.startSelfUpdate(request, onError),
+    };
+}
+export function requireSupply() {
+    throw new Error('workbenchSupply 未提供');
+}

package/dist/host/time.d.ts

@@ -0,0 +1,12 @@
+/**
+ * UTC 时钟（`HH:mm:ss`）：日志与状态行只给人看时分秒，不带日期。
+ * @param value ISO 字符串、时间戳或 Date。
+ * @returns `HH:mm:ss`；非法时间返回 `Invalid Date`。
+ */
+export declare function clockOf(value: string | number | Date): string;
+/**
+ * 把时间戳/ISO 字符串转成毫秒；非法输入给 `NaN`（调用方据此回退）。
+ * @param value ISO 字符串、时间戳或 Date。
+ * @returns 毫秒时间戳或 `NaN`。
+ */
+export declare function epochOf(value: string | number | Date): number;

package/dist/host/time.js

@@ -0,0 +1,19 @@
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc.js';
+dayjs.extend(utc);
+/**
+ * UTC 时钟（`HH:mm:ss`）：日志与状态行只给人看时分秒，不带日期。
+ * @param value ISO 字符串、时间戳或 Date。
+ * @returns `HH:mm:ss`；非法时间返回 `Invalid Date`。
+ */
+export function clockOf(value) {
+    return dayjs(value).utc().format('HH:mm:ss');
+}
+/**
+ * 把时间戳/ISO 字符串转成毫秒；非法输入给 `NaN`（调用方据此回退）。
+ * @param value ISO 字符串、时间戳或 Date。
+ * @returns 毫秒时间戳或 `NaN`。
+ */
+export function epochOf(value) {
+    return dayjs(value).valueOf();
+}

package/dist/host/tokens.d.ts

@@ -0,0 +1,26 @@
+export declare const DSH_THEME_PACKAGE = "@deepseek-ai/dsh-client-ui-theme";
+export declare const SHELL_PACKAGE = "@dsh-workbench/core";
+export declare const DSW_PREFIX = "--dsw-";
+export declare const WB_PREFIX = "--wb-";
+export interface TokenValues {
+    readonly light: string | null;
+    readonly dark: string | null;
+}
+export interface TokenEntry {
+    readonly name: string;
+    readonly values: TokenValues;
+}
+export interface TokenSource {
+    readonly package: string;
+    readonly version: string | null;
+    readonly file: string;
+    readonly entries: readonly TokenEntry[];
+}
+export interface TokenSet {
+    readonly dsw: TokenSource | null;
+    readonly wb: TokenSource | null;
+}
+export declare function tokenEntriesIn(text: string, prefix: string): readonly TokenEntry[];
+export declare function readTokens(startDirs: readonly string[]): TokenSet;
+export declare function nearestTokens(name: string, names: readonly string[], limit?: number): readonly string[];
+export declare function tokenFamilyOf(name: string): string;

package/dist/host/tokens.js

@@ -0,0 +1,154 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+export const DSH_THEME_PACKAGE = '@deepseek-ai/dsh-client-ui-theme';
+export const SHELL_PACKAGE = '@dsh-workbench/core';
+export const DSW_PREFIX = '--dsw-';
+export const WB_PREFIX = '--wb-';
+const BLOCK = /([^{}]*)\{([^{}]*)\}/g;
+const DECLARATION = /(--[a-z0-9-]+)\s*:\s*([^;{}]+)/g;
+const DARK_BLOCK = /data-ds-dark-theme/;
+const VAR_USE = /var\(\s*(--[a-z0-9-]+)\s*(?:,[^()]*)?\)/g;
+function rawDefinitionsIn(text, prefix) {
+    const defs = new Map();
+    for (const block of text.matchAll(BLOCK)) {
+        const selector = block[1] ?? '';
+        const dark = DARK_BLOCK.test(selector);
+        for (const declaration of (block[2] ?? '').matchAll(DECLARATION)) {
+            const name = declaration[1] ?? '';
+            const value = (declaration[2] ?? '').trim();
+            if (!name.startsWith(prefix) || value === '')
+                continue;
+            const found = defs.get(name) ?? {};
+            const key = dark ? 'dark' : 'light';
+            if (found[key] === undefined)
+                found[key] = value;
+            defs.set(name, found);
+        }
+    }
+    return defs;
+}
+function resolved(value, scheme, defs, depth = 0) {
+    if (depth >= 4 || !value.includes('var('))
+        return value;
+    return value.replace(VAR_USE, (whole, name) => {
+        const found = defs.get(name);
+        if (found === undefined)
+            return whole;
+        const next = scheme === 'dark' ? found.dark ?? found.light : found.light ?? found.dark;
+        return next === undefined ? whole : resolved(next, scheme, defs, depth + 1);
+    });
+}
+export function tokenEntriesIn(text, prefix) {
+    const defs = rawDefinitionsIn(text, prefix);
+    return [...defs.entries()]
+        .map(([name, found]) => ({
+        name,
+        values: {
+            light: found.light === undefined ? null : resolved(found.light, 'light', defs),
+            dark: found.dark === undefined ? null : resolved(found.dark, 'dark', defs),
+        },
+    }))
+        .sort((left, right) => left.name.localeCompare(right.name));
+}
+function manifestAt(root) {
+    try {
+        const manifest = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'));
+        if (typeof manifest !== 'object' || manifest === null)
+            return null;
+        const record = manifest;
+        return {
+            name: typeof record.name === 'string' ? record.name : null,
+            version: typeof record.version === 'string' ? record.version : null,
+            root,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function findPackage(startDirs, packageName) {
+    for (const start of startDirs) {
+        if (start.trim() === '')
+            continue;
+        const own = manifestAt(start);
+        if (own !== null && own.name === packageName)
+            return own;
+        let at = resolve(start);
+        for (;;) {
+            const candidate = join(at, 'node_modules', ...packageName.split('/'));
+            const manifest = manifestAt(candidate);
+            if (manifest !== null && (manifest.name === null || manifest.name === packageName))
+                return manifest;
+            const parent = dirname(at);
+            if (parent === at)
+                break;
+            at = parent;
+        }
+    }
+    return null;
+}
+function sourceAt(startDirs, packageName, tail, prefix) {
+    const manifest = findPackage(startDirs, packageName);
+    if (manifest === null)
+        return null;
+    const file = join(manifest.root, tail);
+    if (!existsSync(file))
+        return null;
+    return {
+        package: packageName,
+        version: manifest.version,
+        file,
+        entries: tokenEntriesIn(readFileSync(file, 'utf8'), prefix),
+    };
+}
+export function readTokens(startDirs) {
+    const dsw = sourceAt(startDirs, DSH_THEME_PACKAGE, join('lib', 'client.js'), DSW_PREFIX);
+    const wb = sourceAt(startDirs, SHELL_PACKAGE, 'client.js', WB_PREFIX);
+    return { dsw, wb };
+}
+function distance(left, right) {
+    let previous = Array.from({ length: right.length + 1 }, (_unused, index) => index);
+    for (let row = 1; row <= left.length; row += 1) {
+        const current = [row];
+        for (let column = 1; column <= right.length; column += 1) {
+            const same = left[row - 1] === right[column - 1] ? 0 : 1;
+            current.push(Math.min((previous[column] ?? 0) + 1, (current[column - 1] ?? 0) + 1, (previous[column - 1] ?? 0) + same));
+        }
+        previous = current;
+    }
+    return previous[right.length] ?? 0;
+}
+function commonPrefixLength(left, right) {
+    const cap = Math.min(left.length, right.length);
+    let at = 0;
+    while (at < cap && left[at] === right[at])
+        at += 1;
+    return at;
+}
+export function nearestTokens(name, names, limit = 6) {
+    const wanted = name.trim().toLowerCase();
+    if (wanted === '')
+        return [];
+    const shared = wanted.slice(0, wanted.lastIndexOf('-') + 1);
+    return names
+        .flatMap((one) => {
+        const lower = one.toLowerCase();
+        const typos = lower.length < 3 ? Number.POSITIVE_INFINITY : distance(lower, wanted);
+        if (typos <= 2)
+            return [{ one, typos }];
+        const prefix = commonPrefixLength(lower, wanted);
+        if (prefix < 8)
+            return [];
+        const sameStem = shared.length >= 8 && lower.startsWith(shared);
+        const score = 10 + typos - prefix + (sameStem ? 0 : 20);
+        return score < 20 ? [{ one, typos: score }] : [];
+    })
+        .sort((left, right) => left.typos - right.typos || left.one.length - right.one.length || left.one.localeCompare(right.one))
+        .slice(0, limit)
+        .map((one) => one.one);
+}
+export function tokenFamilyOf(name) {
+    const rest = name.startsWith(DSW_PREFIX) ? name.slice(DSW_PREFIX.length) : name.startsWith(WB_PREFIX) ? name.slice(WB_PREFIX.length) : name;
+    const cut = rest.indexOf('-');
+    return cut === -1 ? rest : rest.slice(0, cut);
+}

package/dist/host/tool-kit.js

@@ -1,4 +1,4 @@
-import { WorkbenchDataError } from './opencli.js';
+import { WorkbenchDataError } from './data-error.js';
 export function sessionWorkspace(exec) {
     const cwd = exec?.agent?.session?.header?.cwd;
     return typeof cwd === 'string' && cwd.trim() !== '' ? cwd.trim() : null;

package/dist/host/unit-face.d.ts

@@ -1,12 +1,13 @@
 import type { DshHostContext } from '../api/dsh.js';
-import type { UnitManifest } from '../api/unit.js';
+import type { UnitManifest } from '../contract/unit.js';
 import type { RouteTable } from '../host/http.js';
 import type { LongTaskBase, LongTaskHost, LongTaskRegistry } from '../host/long-task.js';
-import type { ProvisionHandler } from '../host/provision.js';
-import type { UnitCapability } from './unit-libs.js';
+import type { ProvisionHandler } from './provision.js';
+import type { UnitCapability } from '../contract/unit-capability.js';
 import type { ApprovalCall, ApprovalFacts, ApprovalPolicy } from '../host/tool-approval.js';
 import type { ValueHandoff } from '../host/value-handoff.js';
 import type { WorkspaceStore } from '../host/workspace-store.js';
+import type { DataReader } from '../contract/data.js';
 export interface ToolScopeContext {
     readonly workspace: string | null;
     readonly preset: string | null;
@@ -21,7 +22,7 @@ export interface UnitMountDeps {
     readonly manifests: () => readonly UnitManifest[];
     readonly ownedUnits: () => readonly string[];
     readonly installable?: (() => readonly string[]) | undefined;
-    readonly opencliCommand?: string;
+    readonly data: DataReader;
     readonly store: WorkspaceStore;
     readonly values?: ValueHandoff | undefined;
     readonly probe?: (unit: string, options?: {

package/dist/host/version-range.d.ts

@@ -0,0 +1,2 @@
+export type VersionVerdict = 'satisfied' | 'unsatisfied' | 'malformed';
+export declare function checkVersionRange(contract: string | undefined, version: string): VersionVerdict;