dsh-reference-anything 0.4.2 → 0.4.4

package/lib/contract.d.ts

@@ -44,6 +44,20 @@ export declare const driveCandidateSchema: z.ZodReadonly<z.ZodObject<{
     searchIncomplete: z.ZodOptional<z.ZodBoolean>;
     isDirectory: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>>;
+export declare const localPluginCandidateSchema: z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    label: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    status: z.ZodEnum<{
+        live: "live";
+        disabled: "disabled";
+        inert: "inert";
+    }>;
+    type: z.ZodOptional<z.ZodString>;
+    directory: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
+export type LocalPluginCandidate = z.infer<typeof localPluginCandidateSchema>;
 export declare const searchInputSchema: z.ZodReadonly<z.ZodObject<{
     query: z.ZodString;
     provider: z.ZodOptional<z.ZodEnum<{
@@ -114,6 +128,8 @@ export declare const healthSchema: z.ZodReadonly<z.ZodObject<{
     pluginVersion: z.ZodOptional<z.ZodString>;
     adapterCommandsReady: z.ZodBoolean;
     adapterCompatible: z.ZodBoolean;
+    latestVersion: z.ZodOptional<z.ZodString>;
+    updateAvailable: z.ZodBoolean;
     versionError: z.ZodOptional<z.ZodString>;
     daemonError: z.ZodOptional<z.ZodString>;
     pluginError: z.ZodOptional<z.ZodString>;
@@ -305,6 +321,7 @@ export declare const deleteInputSchema: z.ZodReadonly<z.ZodObject<{
     uriId: z.ZodString;
 }, z.core.$strip>>;
 export declare const storageStatsSchema: z.ZodReadonly<z.ZodObject<{
+    systemTempDirectory: z.ZodOptional<z.ZodString>;
     bytes: z.ZodNumber;
     conversations: z.ZodNumber;
     remoteMissing: z.ZodDefault<z.ZodNumber>;
@@ -409,8 +426,8 @@ export declare const openListMountSchema: z.ZodReadonly<z.ZodObject<{
     enabled: z.ZodBoolean;
     status: z.ZodOptional<z.ZodEnum<{
         error: "error";
-        ready: "ready";
         disabled: "disabled";
+        ready: "ready";
     }>>;
     error: z.ZodOptional<z.ZodString>;
     capacityUsed: z.ZodOptional<z.ZodNumber>;

package/lib/contract.js

@@ -19,6 +19,15 @@ export const driveCandidateSchema = z.object({
     origin: z.string().optional(), updatedAt: z.number().optional(),
     searchIncomplete: z.boolean().optional(), isDirectory: z.boolean().optional(),
 }).strict().readonly();
+export const localPluginCandidateSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    label: z.string(),
+    version: z.string().optional(),
+    status: z.enum(['live', 'disabled', 'inert']),
+    type: z.string().optional(),
+    directory: z.string().optional(),
+}).strict().readonly();
 /**
  * Binds the calling session to the invocation, so the Host can scope a search
  * to the session's cwd. Reintroduced here after 0.3.0 handed file and session
@@ -41,7 +50,7 @@ export const healthSchema = z.object({
     daemonRunning: z.boolean(), extensionConnected: z.boolean(), extensionState: extensionStateSchema,
     extensionVersion: z.string().optional(), profileCount: z.number().int().nonnegative().optional(),
     opencliCompatible: z.boolean(), daemonVersion: z.string().optional(), daemonStale: z.boolean(),
-    connectivityOk: z.boolean(), connectivityChecked: z.boolean(), pluginVersion: z.string().optional(), adapterCommandsReady: z.boolean(), adapterCompatible: z.boolean(),
+    connectivityOk: z.boolean(), connectivityChecked: z.boolean(), pluginVersion: z.string().optional(), adapterCommandsReady: z.boolean(), adapterCompatible: z.boolean(), latestVersion: z.string().optional(), updateAvailable: z.boolean(),
     versionError: z.string().optional(), daemonError: z.string().optional(), pluginError: z.string().optional(), doctorError: z.string().optional(),
 }).readonly();
 export const browserProfileSchema = z.object({ id: z.string(), alias: z.string().optional(), connected: z.boolean(), isDefault: z.boolean() }).readonly();
@@ -84,6 +93,7 @@ export const browsePageSchema = z.object({
 }).readonly();
 export const deleteInputSchema = z.object({ uriId: z.string().min(1) }).readonly();
 export const storageStatsSchema = z.object({
+    systemTempDirectory: z.string().optional(),
     bytes: z.number().int().nonnegative(), conversations: z.number().int().nonnegative(),
     remoteMissing: z.number().int().nonnegative().default(0), oldAccountConversations: z.number().int().nonnegative().default(0),
 }).readonly();
@@ -157,6 +167,7 @@ export const REFERENCE_ANYTHING_INVOCATIONS = [
     descriptor('openListDisableMount', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListDisableMountInput', openListDisableMountSchema) }], strict('Boolean', z.boolean()), true),
     descriptor('openListRemoveMount', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListMountInput', openListMountInputSchema) }], strict('Boolean', z.boolean()), true),
     descriptor('openListReindex', [{ name: 'input', wire: 'input', source: 'json', codec: strict('OpenListMountInput', openListMountInputSchema) }], strict('OpenListReindex', z.object({ supported: z.boolean(), reason: z.string().optional() }).readonly()), true),
+    descriptor('localPlugins', [], strict('LocalPluginCandidate[]', z.array(localPluginCandidateSchema)), true),
 ];
 function strict(type, schema) {
     return { mode: 'strict', typeSymbol: `dsh-reference-anything#${type}`, schema, create: () => schema };

package/lib/host.d.ts

@@ -67,7 +67,7 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
     syncStart(input: {
         providers: ChatProvider[];
         mode: SyncMode;
-    }): string;
+    }): Promise<string>;
     syncStatus(input: {
         jobId: string;
     }): import("./sync/index.ts").SyncJobStatus | undefined;
@@ -98,42 +98,82 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
                 order: number;
                 limit: number;
                 maxCandidates: number;
+                sort: "name" | "updated";
+                shortcut: string;
+                aliases?: string[] | undefined;
+                sourceAliases?: Record<string, string[]> | undefined;
             };
             skills: {
                 enabled: boolean;
                 order: number;
                 limit: number;
                 maxCandidates: number;
+                sort: "name" | "updated";
+                shortcut: string;
+                aliases?: string[] | undefined;
+                sourceAliases?: Record<string, string[]> | undefined;
             };
             files: {
                 enabled: boolean;
                 order: number;
                 limit: number;
                 maxCandidates: number;
+                sort: "name" | "updated";
+                shortcut: string;
+                aliases?: string[] | undefined;
+                sourceAliases?: Record<string, string[]> | undefined;
             };
             sessions: {
                 enabled: boolean;
                 order: number;
                 limit: number;
                 maxCandidates: number;
+                sort: "name" | "updated";
+                shortcut: string;
+                aliases?: string[] | undefined;
+                sourceAliases?: Record<string, string[]> | undefined;
             };
             agents: {
                 enabled: boolean;
                 order: number;
                 limit: number;
                 maxCandidates: number;
+                sort: "name" | "updated";
+                shortcut: string;
+                aliases?: string[] | undefined;
+                sourceAliases?: Record<string, string[]> | undefined;
             };
             conversations: {
                 enabled: boolean;
                 order: number;
                 limit: number;
                 maxCandidates: number;
+                sort: "name" | "updated";
+                shortcut: string;
+                aliases?: string[] | undefined;
+                sourceAliases?: Record<string, string[]> | undefined;
             };
             drives: {
                 enabled: boolean;
                 order: number;
                 limit: number;
                 maxCandidates: number;
+                sort: "name" | "updated";
+                shortcut: string;
+                aliases?: string[] | undefined;
+                sourceAliases?: Record<string, string[]> | undefined;
+            };
+            plugins: {
+                enabled: boolean;
+                order: number;
+                limit: number;
+                maxCandidates: number;
+                sort: "name" | "updated";
+                shortcut: string;
+                onlyLive: boolean;
+                showDeepSeek: boolean;
+                aliases?: string[] | undefined;
+                sourceAliases?: Record<string, string[]> | undefined;
             };
         } | undefined;
     }>;
@@ -150,7 +190,13 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
     deleteConversation(input: {
         uriId: string;
     }, signal: AbortSignal): Promise<boolean>;
-    storageStats(): import("./store/store.ts").StorageStats;
+    storageStats(): {
+        systemTempDirectory: string;
+        bytes: number;
+        conversations: number;
+        remoteMissing: number;
+        oldAccountConversations: number;
+    };
     clearProvider(input: {
         provider: ChatProvider;
     }, signal: AbortSignal): Promise<number>;
@@ -191,4 +237,13 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
     }, signal: AbortSignal): Promise<{
         supported: true;
     }>;
+    localPlugins(signal: AbortSignal): Promise<readonly Readonly<{
+        id: string;
+        name: string;
+        label: string;
+        status: "live" | "disabled" | "inert";
+        version?: string | undefined;
+        type?: string | undefined;
+        directory?: string | undefined;
+    }>[]>;
 }

package/lib/host.js

@@ -2,6 +2,7 @@ import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import { tmpdir } from 'node:os';
 import { spawn } from 'node:child_process';
 import { validateDownloadDirectory } from "./download-directory.js";
+import { resolveLocalPlugins } from "./local-plugins.js";
 export class ReferenceAnythingRemote extends TypertRemoteService {
     constructor(ctx) { super(ctx, 'referenceAnything'); }
     /**
@@ -75,7 +76,8 @@ export class ReferenceAnythingRemote extends TypertRemoteService {
     checkUpdate(signal) { return this.ctx.referenceChatHistory.checkUpdate(signal); }
     installUpdate(signal) { return this.ctx.referenceChatHistory.installUpdate(signal); }
     stats() { return this.ctx.referenceChatHistory.stats(); }
-    syncStart(input) {
+    async syncStart(input) {
+        await this.ctx.referenceChatHistory.ensureBrowser();
         return this.ctx.referenceChatHistory.sync.start(input.providers, input.mode);
     }
     syncStatus(input) { return this.ctx.referenceChatHistory.sync.status(input.jobId); }
@@ -107,7 +109,7 @@ export class ReferenceAnythingRemote extends TypertRemoteService {
         signal.throwIfAborted();
         return this.ctx.referenceChatHistory.remove(input.uriId);
     }
-    storageStats() { return this.ctx.referenceChatHistory.storageStats(); }
+    storageStats() { return { ...this.ctx.referenceChatHistory.storageStats(), systemTempDirectory: tmpdir() }; }
     clearProvider(input, signal) {
         signal.throwIfAborted();
         return this.ctx.referenceChatHistory.removeProvider(input.provider);
@@ -132,4 +134,8 @@ export class ReferenceAnythingRemote extends TypertRemoteService {
     async openListDisableMount(input, signal) { await this.ctx.openListManager.disableMount(input.id, input.disabled ?? true, signal); return true; }
     async openListRemoveMount(input, signal) { await this.ctx.openListManager.removeMount(input.id, signal); return true; }
     openListReindex(input, signal) { return this.ctx.openListManager.reindexMount(input.id, signal); }
+    localPlugins(signal) {
+        signal.throwIfAborted();
+        return resolveLocalPlugins(this.ctx);
+    }
 }

package/lib/index.js

@@ -79,8 +79,6 @@ export default class ReferenceRuntime extends Service {
     static grantKey(ref) { return `${ref.source}\u0000${ref.id}`; }
     static contentMentions(blocks, key) {
         return blocks.some(block => {
-            if (block.type === 'tool-result')
-                return ReferenceRuntime.contentMentions(block.content, key);
             if (block.type !== 'text' || !mayContainReference(block.text))
                 return false;
             try {

package/lib/local-plugins.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { LocalPluginCandidate } from './contract.ts';
+import type { ReferenceSource } from './types.ts';
+export declare function createPluginReferenceSource(ctx: Context): ReferenceSource;
+/** Read the active loader's composed entries, including bundle patches and effective disables. */
+export declare function resolveLocalPlugins(ctx: Context): Promise<readonly LocalPluginCandidate[]>;

package/lib/local-plugins.js

@@ -0,0 +1,119 @@
+import { readFile, realpath, stat } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { dirname, isAbsolute, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { z } from 'zod';
+import { sliceTurns } from "./window.js";
+export function createPluginReferenceSource(ctx) {
+    return {
+        id: 'local-plugin', requiresGrant: true,
+        available: async () => Boolean(ctx.get('loader')),
+        async list(query, limit, signal) {
+            signal?.throwIfAborted();
+            return (await resolveLocalPlugins(ctx)).filter(row => row.name.toLowerCase().includes(query.toLowerCase())).slice(0, limit)
+                .map(row => ({ ref: { source: 'local-plugin', id: row.name }, label: row.name }));
+        },
+        async read(ref, window, signal) {
+            signal?.throwIfAborted();
+            const plugin = (await resolveLocalPlugins(ctx)).find(row => row.name === ref.id);
+            if (!plugin?.directory)
+                throw new Error(`Plugin directory unavailable: ${ref.id}`);
+            return {
+                ref, label: plugin.name, partial: false, capturedAt: Date.now(),
+                body: sliceTurns([{ role: 'document', text: JSON.stringify({ name: plugin.name, version: plugin.version, directory: plugin.directory, note: 'Use file tools to inspect this plugin directory. Source contents have not been read.' }) }], window),
+            };
+        },
+    };
+}
+const manifestSchema = z.object({
+    name: z.string().optional(), version: z.string().optional(),
+    dependencies: z.record(z.string(), z.string()).optional(),
+    dsh: z.object({
+        bundle: z.object({ patch: z.string() }).optional(),
+        client: z.unknown().optional(),
+        profile: z.object({ bundles: z.array(z.string()).optional() }).optional(),
+    }).optional(),
+});
+async function readManifest(directory) {
+    try {
+        return manifestSchema.parse(JSON.parse(await readFile(join(directory, 'package.json'), 'utf8')));
+    }
+    catch {
+        return undefined; /* Missing or invalid optional metadata must not hide a configured entry. */
+    }
+}
+async function pluginPackage(name, baseUrl) {
+    if (!baseUrl?.startsWith('file:'))
+        return undefined;
+    const require = createRequire(new URL('./package.json', baseUrl));
+    if (!name.startsWith('.') && !name.startsWith('/') && !name.includes(':')) {
+        const packageName = name.split('/').slice(0, name.startsWith('@') ? 2 : 1).join('/');
+        for (const searchPath of require.resolve.paths(packageName) ?? []) {
+            const directory = join(searchPath, packageName);
+            const manifest = await readManifest(directory);
+            if (manifest)
+                return { directory: await realpath(directory), manifest };
+        }
+        return undefined;
+    }
+    try {
+        const url = isAbsolute(name) ? pathToFileURL(name) : new URL(name.replace(/\\/gu, '/'), baseUrl);
+        const path = await realpath(fileURLToPath(url));
+        const directory = (await stat(path)).isDirectory() ? path : dirname(path);
+        let parent = directory;
+        while (true) {
+            const manifest = await readManifest(parent);
+            if (manifest)
+                return manifest.dsh?.profile ? { directory, manifest: {} } : { directory: parent, manifest };
+            if (dirname(parent) === parent)
+                return { directory, manifest: {} };
+            parent = dirname(parent);
+        }
+    }
+    catch {
+        return undefined; /* A disabled or failed local entry may no longer exist on disk. */
+    }
+}
+const STATUS_ORDER = { live: 0, inert: 1, disabled: 2 };
+// Cordis publishes FiberState as an ambient const enum, unavailable with verbatimModuleSyntax.
+const ACTIVE = 2; // FiberState.ACTIVE
+/** Read the active loader's composed entries, including bundle patches and effective disables. */
+export async function resolveLocalPlugins(ctx) {
+    const loader = ctx.get('loader');
+    if (!loader)
+        return [];
+    const plugins = new Map();
+    for (const entry of loader.entries()) {
+        if (entry.options.name.startsWith('cordis:') || entry.options.group)
+            continue;
+        const info = await pluginPackage(entry.options.name, entry.parent.tree.ctx.baseUrl);
+        const name = info?.manifest.name ?? entry.options.name;
+        const status = entry.disabled ? 'disabled' : entry.fiber?.state === ACTIVE ? 'live' : 'inert';
+        const previous = plugins.get(name);
+        if (previous && STATUS_ORDER[previous.status] <= STATUS_ORDER[status])
+            continue;
+        plugins.set(name, {
+            id: entry.id, name, label: name, status,
+            ...(info ? { directory: info.directory, version: info.manifest.version } : {}),
+        });
+    }
+    // Installed bundles/client plugins can exist without a host entry. Ordinary dependencies are omitted.
+    const baseUrl = loader.root.ctx.baseUrl;
+    if (baseUrl?.startsWith('file:')) {
+        const profile = await readManifest(fileURLToPath(new URL('.', baseUrl)));
+        const bundles = new Set(profile?.dsh?.profile?.bundles ?? []);
+        for (const packageName of new Set([...Object.keys(profile?.dependencies ?? {}), ...bundles])) {
+            const info = await pluginPackage(packageName, baseUrl);
+            if (!bundles.has(packageName) && !info?.manifest.dsh?.bundle && !info?.manifest.dsh?.client)
+                continue;
+            const name = info?.manifest.name ?? packageName;
+            if (plugins.has(name))
+                continue;
+            plugins.set(name, {
+                id: packageName, name, label: name, status: 'inert',
+                ...(info ? { directory: info.directory, version: info.manifest.version } : {}),
+            });
+        }
+    }
+    return [...plugins.values()].sort((a, b) => STATUS_ORDER[a.status] - STATUS_ORDER[b.status] || a.name.localeCompare(b.name));
+}

package/lib/opencli.d.ts

@@ -38,6 +38,8 @@ export interface OpenCliHealth {
     pluginVersion?: string;
     adapterCommandsReady: boolean;
     adapterCompatible: boolean;
+    latestVersion?: string;
+    updateAvailable: boolean;
     versionError?: string;
     daemonError?: string;
     pluginError?: string;
@@ -107,6 +109,7 @@ export declare class OpenCliRunner {
     /** Confirm the executable also exposes OpenCLI's plugin command, not merely a semver-looking --version. */
     verifyInstallation(signal?: AbortSignal): Promise<void>;
     profiles(signal?: AbortSignal): Promise<BrowserProfile[]>;
+    ensureBrowser(signal?: AbortSignal): Promise<void>;
     installPlugin(pluginUrl: string, signal?: AbortSignal): Promise<void>;
     restartDaemon(signal?: AbortSignal): Promise<void>;
     private probe;

package/lib/opencli.js

@@ -1,7 +1,8 @@
 import { execFile as nodeExecFile } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { delimiter, dirname, join, resolve } from 'node:path';
 import { promisify } from 'node:util';
+import { spawn } from 'node:child_process';
 import { createHash } from 'node:crypto';
 const execFile = promisify(nodeExecFile);
 export const MIN_OPENCLI_VERSION = '1.8.6';
@@ -124,9 +125,10 @@ export class OpenCliRunner {
         return this.inspectHealth(false, signal);
     }
     async inspectHealth(checkConnectivity, signal) {
-        const [version, daemon, plugins, doctor] = await Promise.all([
+        const [version, daemon, plugins, doctor, latest] = await Promise.all([
             this.probe(['--version'], signal), this.probe(['daemon', 'status'], signal), this.probe(['plugin', 'list'], signal),
             checkConnectivity ? this.probe(['doctor'], signal) : Promise.resolve({ value: '', diagnostic: '' }),
+            latestOpenCliVersion(signal),
         ]);
         const status = parseDaemonStatus(daemon.value);
         const cliVersion = normalizeVersion(version.value);
@@ -149,6 +151,8 @@ export class OpenCliRunner {
             ...(pluginVersion ? { pluginVersion: normalizeVersion(pluginVersion) } : {}),
             adapterCommandsReady,
             adapterCompatible: pluginInstalled && adapterCommandsReady && versionAtLeast(pluginVersion ?? '', MIN_ADAPTER_VERSION),
+            ...(latest.value.trim() ? { latestVersion: normalizeVersion(latest.value) } : {}),
+            updateAvailable: Boolean(latest.value.trim() && versionAtLeast(normalizeVersion(latest.value), cliVersion) && normalizeVersion(latest.value) !== cliVersion),
             ...(version.error ? { versionError: version.error } : {}),
             ...(daemon.error ? { daemonError: daemon.error } : {}),
             ...(plugins.error || adapterLoadError ? { pluginError: plugins.error || adapterLoadError } : {}),
@@ -171,6 +175,22 @@ export class OpenCliRunner {
                     connected: match[3] === 'connected' && (disconnected < 0 || position < disconnected), isDefault: /\sdefault\s+—/.test(line) }];
         });
     }
+    async ensureBrowser(signal) {
+        if ((await this.profiles(signal)).some(profile => profile.connected))
+            return;
+        const child = process.platform === 'win32'
+            ? spawn('cmd.exe', ['/c', 'start', '', 'msedge.exe', 'about:blank'], { detached: true, stdio: 'ignore', windowsHide: true })
+            : process.platform === 'darwin'
+                ? spawn('open', ['-a', 'Google Chrome', 'about:blank'], { detached: true, stdio: 'ignore' })
+                : spawn('xdg-open', ['about:blank'], { detached: true, stdio: 'ignore' });
+        child.unref();
+        for (let i = 0; i < 20; i++) {
+            await new Promise(resolve => setTimeout(resolve, 500));
+            if ((await this.profiles(signal)).some(profile => profile.connected))
+                return;
+        }
+        throw new OpenCliError('Browser started, but the OpenCLI extension did not connect', 'EXTENSION_NOT_CONNECTED');
+    }
     async installPlugin(pluginUrl, signal) {
         const before = await this.command(['plugin', 'list'], signal);
         if (new RegExp(`\\b${ADAPTER_PLUGIN_NAME}\\b`, 'i').test(before.stdout)) {
@@ -259,6 +279,18 @@ export class OpenCliRunner {
         }
     }
 }
+async function latestOpenCliVersion(signal) {
+    const npm = resolveNpmInvocation();
+    if (!npm)
+        return { value: '', diagnostic: '' };
+    try {
+        const result = await execFile(npm.file, [...npm.prefix, 'view', OPENCLI_NPM_PACKAGE, 'version'], { encoding: 'utf8', timeout: 15_000, signal });
+        return { value: String(result.stdout).trim(), diagnostic: '' };
+    }
+    catch {
+        return { value: '', diagnostic: '' };
+    }
+}
 /** Keep successful-process diagnostics: OpenCLI reports plugin import failures on stderr while exiting zero. */
 function adapterPluginLoadError(diagnostic = '') {
     const lines = diagnostic.split(/\r?\n/)
@@ -323,19 +355,40 @@ function openCliCandidates(configured) {
     return [...new Set(candidates.filter(Boolean))];
 }
 function resolveNpmInvocation() {
+    const node = resolveNodeExecutable();
     const npmExecPath = process.env.npm_execpath;
     if (npmExecPath && existsSync(npmExecPath)) {
         return /\.(?:c?js|mjs)$/i.test(npmExecPath)
-            ? { file: process.execPath, prefix: [npmExecPath] }
+            ? { file: node, prefix: [npmExecPath] }
             : { file: npmExecPath, prefix: [] };
     }
-    const besideNode = join(dirname(process.execPath), 'node_modules', 'npm', 'bin', 'npm-cli.js');
-    if (existsSync(besideNode))
-        return { file: process.execPath, prefix: [besideNode] };
+    const npmEntries = [
+        join(dirname(node), 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+        join(dirname(node), '..', 'node_modules', 'npm', 'bin', 'npm-cli.js'),
+    ];
+    for (const entry of npmEntries)
+        if (existsSync(entry))
+            return { file: node, prefix: [entry] };
     if (process.platform !== 'win32')
         return { file: 'npm', prefix: [] };
     return undefined;
 }
+/** Electron Node mode still advertises Electron, so CLI parsers misread argv. */
+function resolveNodeExecutable(shimDirectory) {
+    if (!process.versions.electron)
+        return process.execPath;
+    const binary = process.platform === 'win32' ? 'node.exe' : 'node';
+    const resources = process.platform === 'darwin'
+        ? resolve(dirname(process.execPath), '..', 'Resources')
+        : join(dirname(process.execPath), 'resources');
+    const candidates = [
+        ...(shimDirectory ? [join(shimDirectory, binary)] : []),
+        // Official Desktop ships a standalone dependency runtime as well as Electron.
+        join(resources, 'runtime', 'primary-runtime', 'dependencies', 'node', 'bin', binary),
+        ...(process.env.PATH ?? '').split(delimiter).filter(Boolean).map(path => join(path.replace(/^"|"$/g, ''), binary)),
+    ];
+    return candidates.find(candidate => existsSync(candidate) && resolve(candidate) !== resolve(process.execPath)) ?? 'node';
+}
 function normalizeVersion(value) { return value.trim().replace(/^v/i, '').split(/\s+/)[0] ?? ''; }
 /** Numeric semver comparison for the stable x.y.z versions OpenCLI publishes. */
 export function versionAtLeast(value, minimum) {
@@ -357,12 +410,12 @@ function resolveInvocation(configured) {
     if (/\.cmd$/i.test(configured) && existsSync(explicit)) {
         const entry = join(explicit, '..', 'node_modules', '@jackwener', 'opencli', 'dist', 'src', 'main.js');
         if (existsSync(entry))
-            return { file: process.execPath, prefix: [entry] };
+            return { file: resolveNodeExecutable(dirname(explicit)), prefix: [entry] };
     }
     if (process.platform === 'win32' && configured === 'opencli') {
         const entry = process.env.APPDATA && join(process.env.APPDATA, 'npm', 'node_modules', '@jackwener', 'opencli', 'dist', 'src', 'main.js');
         if (entry && existsSync(entry))
-            return { file: process.execPath, prefix: [entry] };
+            return { file: resolveNodeExecutable(join(process.env.APPDATA, 'npm')), prefix: [entry] };
     }
     return { file: configured, prefix: [] };
 }

package/lib/reference.js

@@ -158,8 +158,7 @@ function notice(summary) {
                 text: `A conversation reference in the previous message could not be resolved: ${summary}`,
             }],
         source: {
-            kind: 'plugin',
-            plugin: name,
+            kind: 'reference-anything',
             form: 'notice',
             summary: boundContextSummary(summary),
         },

package/lib/sources/web-chat/index.d.ts

@@ -100,6 +100,7 @@ export default class WebChatHistoryService extends Service implements ReferenceS
     health(signal?: AbortSignal): Promise<import("../../opencli.ts").OpenCliHealth>;
     quickHealth(signal?: AbortSignal): Promise<import("../../opencli.ts").OpenCliHealth>;
     profiles(signal?: AbortSignal): Promise<import("../../opencli.ts").BrowserProfile[]>;
+    ensureBrowser(signal?: AbortSignal): Promise<void>;
     private runner;
     installAdapter(signal?: AbortSignal): Promise<boolean>;
     private installAdapterFrom;

package/lib/sources/web-chat/index.js

@@ -123,6 +123,7 @@ export default class WebChatHistoryService extends Service {
             end = decodeLiveCursor(window.cursor, conversationKey);
         let rows;
         try {
+            await this.ensureBrowser(signal);
             rows = await this.runner().detail(conversation.provider, conversation.externalId, signal, conversation.accountScope);
         }
         catch (error) {
@@ -208,7 +209,12 @@ export default class WebChatHistoryService extends Service {
             throw new ReferenceAnythingError('wait for the current conversation sync to finish before updating', 'REFERENCE_SYNC_IN_PROGRESS');
         return this.packageUpdates.update(signal);
     }
-    async restartDaemon(signal) { await this.runner().restartDaemon(signal); return true; }
+    async restartDaemon(signal) {
+        const runner = this.runner();
+        await runner.restartDaemon(signal);
+        await this.ensureBrowser(signal);
+        return true;
+    }
     async discoverOpenCli(signal) {
         return discoverOpenCli(this.store.settings.opencliPath, signal);
     }
@@ -267,6 +273,20 @@ export default class WebChatHistoryService extends Service {
         return new OpenCliRunner({ executable: settings.opencliPath, profile: '',
             timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes }).profiles(signal);
     }
+    async ensureBrowser(signal) {
+        const settings = this.store.settings;
+        const runner = this.runner();
+        const connected = await runner.profiles(signal);
+        const selected = connected.find(profile => profile.connected);
+        if (selected && !settings.profile) {
+            await this.store.setSettings({ ...settings, profile: selected.alias || selected.id });
+            return;
+        }
+        await runner.ensureBrowser(signal);
+        const after = (await runner.profiles(signal)).find(profile => profile.connected);
+        if (after)
+            await this.store.setSettings({ ...settings, profile: after.alias || after.id });
+    }
     runner() {
         const settings = this.store.settings;
         return new OpenCliRunner({ executable: settings.opencliPath, profile: settings.profile,