dsh-reference-anything 0.4.3 → 0.5.0

package/lib/contract.d.ts

@@ -3,7 +3,7 @@ import type { InvocationDescriptor } from '@deepseek-ai/dsh-typert-protocol';
 /**
  * One local-agent transcript as the `@` menu sees it.
  *
- * `id` is the source-scoped `kind:relPath`, not a `dsh-ref:` URI — the client
+ * `id` is a source-scoped `kind:relPath` or an opaque import-only selection, not a `dsh-ref:` URI — the client
  * wraps it, the way it does for web chats, so the `'local-agent'` source string
  * stays hardcoded in exactly one place. Deliberately carries no `origin`: the
  * absolute path adds nothing a menu row can use and everything a screen-share
@@ -15,9 +15,19 @@ export declare const agentCandidateSchema: z.ZodReadonly<z.ZodObject<{
     label: z.ZodString;
     provider: z.ZodString;
     updatedAt: z.ZodOptional<z.ZodNumber>;
+    referenceId: z.ZodOptional<z.ZodString>;
+    importOnly: z.ZodOptional<z.ZodBoolean>;
+    importStatus: z.ZodOptional<z.ZodEnum<{
+        imported: "imported";
+        partial: "partial";
+        "not-imported": "not-imported";
+        archived: "archived";
+    }>>;
+    warning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
 export declare const agentStatsSchema: z.ZodReadonly<z.ZodObject<{
     agent: z.ZodEnum<{
+        chatgpt: "chatgpt";
         kimi: "kimi";
         "claude-code": "claude-code";
         codex: "codex";
@@ -32,8 +42,26 @@ export declare const agentStatsSchema: z.ZodReadonly<z.ZodObject<{
         opencode: "opencode";
         mimocode: "mimocode";
         zcode: "zcode";
+        antigravity: "antigravity";
+        kilocode: "kilocode";
+        workbuddy: "workbuddy";
+        qwen: "qwen";
+        continue: "continue";
+        cline: "cline";
+        goose: "goose";
+        dsh4: "dsh4";
+        zed: "zed";
+        crush: "crush";
+        teleagent: "teleagent";
+        trae: "trae";
+        vibe: "vibe";
+        dsh: "dsh";
     }>;
     conversations: z.ZodNumber;
+    error: z.ZodOptional<z.ZodString>;
+    unavailable: z.ZodOptional<z.ZodBoolean>;
+    paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    readable: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>>;
 export declare const driveCandidateSchema: z.ZodReadonly<z.ZodObject<{
     id: z.ZodString;
@@ -44,6 +72,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<{
@@ -57,8 +99,8 @@ export declare const searchInputSchema: z.ZodReadonly<z.ZodObject<{
     limit: z.ZodNumber;
 }, z.core.$strip>>;
 export declare const matchedViaSchema: z.ZodEnum<{
-    recent: "recent";
     title: "title";
+    recent: "recent";
     content: "content";
 }>;
 export declare const searchResultSchema: z.ZodReadonly<z.ZodObject<{
@@ -78,8 +120,8 @@ export declare const searchResultSchema: z.ZodReadonly<z.ZodObject<{
     partial: z.ZodBoolean;
     syncedAt: z.ZodString;
     matchedVia: z.ZodEnum<{
-        recent: "recent";
         title: "title";
+        recent: "recent";
         content: "content";
     }>;
     snippet: z.ZodOptional<z.ZodString>;
@@ -106,6 +148,9 @@ export declare const healthSchema: z.ZodReadonly<z.ZodObject<{
     }>;
     extensionVersion: z.ZodOptional<z.ZodString>;
     profileCount: z.ZodOptional<z.ZodNumber>;
+    latestExtensionVersion: z.ZodOptional<z.ZodString>;
+    extensionUpdateAvailable: z.ZodOptional<z.ZodBoolean>;
+    extensionCompatible: z.ZodOptional<z.ZodBoolean>;
     opencliCompatible: z.ZodBoolean;
     daemonVersion: z.ZodOptional<z.ZodString>;
     daemonStale: z.ZodBoolean;
@@ -141,6 +186,8 @@ export declare const packageUpdateStatusSchema: z.ZodReadonly<z.ZodObject<{
     releaseNotes: z.ZodOptional<z.ZodString>;
     releaseUrl: z.ZodOptional<z.ZodString>;
     error: z.ZodOptional<z.ZodString>;
+    currentReleaseNotes: z.ZodOptional<z.ZodString>;
+    currentReleaseUrl: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>>;
 export declare const packageUpdateResultSchema: z.ZodReadonly<z.ZodObject<{
     version: z.ZodString;
@@ -412,8 +459,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>;
@@ -451,4 +498,18 @@ export declare const openListDisableMountSchema: z.ZodReadonly<z.ZodObject<{
 export declare const openListUpgradeInputSchema: z.ZodReadonly<z.ZodObject<{
     rollback: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>>;
+export declare const chatImportCompatibilitySchema: z.ZodReadonly<z.ZodObject<{
+    state: z.ZodEnum<{
+        unavailable: "unavailable";
+        disabled: "disabled";
+        ready: "ready";
+        incompatible: "incompatible";
+        installing: "installing";
+        "restart-required": "restart-required";
+    }>;
+    version: z.ZodString;
+    missing: z.ZodArray<z.ZodString>;
+    canUpgrade: z.ZodBoolean;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>>;
 export declare const REFERENCE_ANYTHING_INVOCATIONS: readonly InvocationDescriptor[];

package/lib/contract.js

@@ -3,14 +3,14 @@ import { localAgentSchema, providerSchema, settingsRecordSchema } from "./wire.j
 /**
  * One local-agent transcript as the `@` menu sees it.
  *
- * `id` is the source-scoped `kind:relPath`, not a `dsh-ref:` URI — the client
+ * `id` is a source-scoped `kind:relPath` or an opaque import-only selection, not a `dsh-ref:` URI — the client
  * wraps it, the way it does for web chats, so the `'local-agent'` source string
  * stays hardcoded in exactly one place. Deliberately carries no `origin`: the
  * absolute path adds nothing a menu row can use and everything a screen-share
  * leaks.
  */
-export const agentCandidateSchema = z.object({ id: z.string(), kind: z.string(), label: z.string(), provider: z.string(), updatedAt: z.number().optional() }).readonly();
-export const agentStatsSchema = z.object({ agent: localAgentSchema, conversations: z.number().int().nonnegative() }).readonly();
+export const agentCandidateSchema = z.object({ id: z.string(), kind: z.string(), label: z.string(), provider: z.string(), updatedAt: z.number().optional(), referenceId: z.string().optional(), importOnly: z.boolean().optional(), importStatus: z.enum(['imported', 'partial', 'not-imported', 'archived']).optional(), warning: z.string().optional() }).readonly();
+export const agentStatsSchema = z.object({ agent: localAgentSchema, conversations: z.number().int().nonnegative(), error: z.string().optional(), unavailable: z.boolean().optional(), paths: z.array(z.string()).optional(), readable: z.boolean().optional() }).readonly();
 // `origin` is the drive's own display path, shown under the candidate. It is
 // never a download URL: those are signed with the account's credential and
 // must not cross this wire.
@@ -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
@@ -40,6 +49,7 @@ export const healthSchema = z.object({
     version: z.string(), daemon: z.string(), pluginInstalled: z.boolean(),
     daemonRunning: z.boolean(), extensionConnected: z.boolean(), extensionState: extensionStateSchema,
     extensionVersion: z.string().optional(), profileCount: z.number().int().nonnegative().optional(),
+    latestExtensionVersion: z.string().optional(), extensionUpdateAvailable: z.boolean().optional(), extensionCompatible: z.boolean().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(), latestVersion: z.string().optional(), updateAvailable: z.boolean(),
     versionError: z.string().optional(), daemonError: z.string().optional(), pluginError: z.string().optional(), doctorError: z.string().optional(),
@@ -51,6 +61,7 @@ export const openCliDiscoverySchema = z.object({
 export const packageUpdateStatusSchema = z.object({
     currentVersion: z.string(), latestVersion: z.string(), updateAvailable: z.boolean(),
     checkedAt: z.number().int().nonnegative(), releaseNotes: z.string().max(12_000).optional(), releaseUrl: z.string().url().optional(), error: z.string().optional(),
+    currentReleaseNotes: z.string().max(12_000).optional(), currentReleaseUrl: z.string().url().optional(),
 }).readonly();
 export const packageUpdateResultSchema = z.object({
     version: z.string(), restartRequired: z.boolean(),
@@ -116,8 +127,16 @@ export const openListMountCreateSchema = z.object({ id: z.string().min(1).option
 export const openListMountInputSchema = z.object({ id: z.string().min(1) }).strict().readonly();
 export const openListDisableMountSchema = z.object({ id: z.string().min(1), disabled: z.boolean().optional() }).strict().readonly();
 export const openListUpgradeInputSchema = z.object({ rollback: z.boolean().optional() }).strict().readonly();
+export const chatImportCompatibilitySchema = z.object({
+    state: z.enum(['ready', 'incompatible', 'unavailable', 'disabled', 'installing', 'restart-required']),
+    version: z.string(), missing: z.array(z.string()), canUpgrade: z.boolean(), error: z.string().optional(),
+}).strict().readonly();
 export const REFERENCE_ANYTHING_INVOCATIONS = [
-    descriptor('agentSearch', [agentLookup, { name: 'input', wire: 'input', source: 'json', codec: strict('AgentSearchInput', z.object({ query: z.string(), limit: z.number().int().min(1).max(100) }).readonly()) }], strict('AgentCandidate[]', z.array(agentCandidateSchema)), true),
+    descriptor('chatImportStatus', [], strict('ChatImportCompatibility', chatImportCompatibilitySchema)),
+    descriptor('chatImportUpgradeInstall', [], strict('ChatImportCompatibility', chatImportCompatibilitySchema), true),
+    descriptor('agentResume', [agentLookup, { name: 'input', wire: 'input', source: 'json', codec: strict('AgentResumeInput', z.object({ id: z.string().min(1) }).strict().readonly()) }], strict('ResumeSummary', z.string().min(1)), true),
+    descriptor('agentImport', [agentLookup, { name: 'input', wire: 'input', source: 'json', codec: strict('AgentImportInput', z.object({ id: z.string().min(1) }).strict().readonly()) }], strict('ImportedSessionId', z.string().min(1)), true),
+    descriptor('agentSearch', [agentLookup, { name: 'input', wire: 'input', source: 'json', codec: strict('AgentSearchInput', z.object({ query: z.string(), limit: z.number().int().min(1).max(100), kind: localAgentSchema.optional() }).readonly()) }], strict('AgentCandidate[]', z.array(agentCandidateSchema)), true),
     descriptor('agentStats', [], strict('AgentStats[]', z.array(agentStatsSchema)), true),
     // No session lookup, unlike `agentSearch`: a drive is the same drive from
     // every workspace, so there is nothing to scope the query to.
@@ -158,6 +177,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/conversation-availability.d.ts

@@ -0,0 +1,13 @@
+import type { ChatImportTarget } from './chat-import-reader.ts';
+/** Unknown/error rows stay visible. One background parser never delays discovery. */
+export declare class ConversationAvailability {
+    private cache;
+    private queued;
+    private worker?;
+    private active?;
+    private timer?;
+    visible(target: ChatImportTarget): Promise<boolean>;
+    private next;
+    private failed;
+    dispose(): void;
+}

package/lib/conversation-availability.js

@@ -0,0 +1,76 @@
+import { stat } from 'node:fs/promises';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+/** Unknown/error rows stay visible. One background parser never delays discovery. */
+export class ConversationAvailability {
+    cache = new Map();
+    queued = new Map();
+    worker;
+    active;
+    timer;
+    async visible(target) {
+        const key = JSON.stringify(target);
+        const entry = this.cache.get(key);
+        if (entry) {
+            const unchanged = (await Promise.all(entry.dependencies.map(async ([path, version]) => {
+                try {
+                    const s = await stat(path);
+                    return version === `${s.size}:${s.mtimeMs}:${s.ctimeMs}`;
+                }
+                catch (error) {
+                    return error.code === 'ENOENT' && version === 'missing';
+                }
+            }))).every(Boolean);
+            if (unchanged && (entry.state !== 'unknown' || Date.now() - entry.checked < 300_000))
+                return entry.state !== 'empty';
+            this.cache.delete(key);
+        }
+        if (this.active !== key && this.queued.size < 128)
+            this.queued.set(key, target);
+        this.next();
+        return true;
+    }
+    next() {
+        if (this.active || !this.queued.size)
+            return;
+        const [id, target] = this.queued.entries().next().value;
+        this.queued.delete(id);
+        this.active = id;
+        if (!this.worker) {
+            // Native parser failures and V8 OOM must not terminate the DSH host.
+            this.worker = spawn(process.execPath, ['--max-old-space-size=256', fileURLToPath(new URL('../vendor/chat-import-reader/availability-worker.mjs', import.meta.url))], {
+                windowsHide: true, stdio: ['ignore', 'ignore', 'ignore', 'ipc'],
+            });
+            this.worker.on('message', (result) => {
+                if (result.id !== this.active)
+                    return;
+                clearTimeout(this.timer);
+                if (this.cache.size >= 2000)
+                    this.cache.delete(this.cache.keys().next().value);
+                this.cache.set(result.id, { ...result, checked: Date.now() });
+                this.active = undefined;
+                this.next();
+            });
+            this.worker.on('error', () => this.failed());
+            this.worker.on('exit', () => this.failed());
+            this.worker.unref();
+            this.worker.channel?.unref();
+        }
+        this.timer = setTimeout(() => this.failed(), 15_000);
+        this.timer.unref();
+        this.worker.send({ id, target });
+    }
+    failed() {
+        if (this.active)
+            this.cache.set(this.active, { state: 'unknown', dependencies: [], checked: Date.now() });
+        this.dispose();
+        this.next();
+    }
+    dispose() {
+        clearTimeout(this.timer);
+        this.worker?.removeAllListeners();
+        this.worker?.kill();
+        this.worker = undefined;
+        this.active = undefined;
+    }
+}

package/lib/errors.d.ts

@@ -5,9 +5,9 @@
  */
 import { HarnessError } from '@deepseek-ai/dsh-llm';
 /** Stable, machine-routable failure classes; route on these, never on message text. */
-export type ReferenceErrorCode = 
+export type ReferenceErrorCode = 'INVALID_ARGUMENT' | 'SOURCE_DISABLED' | 'ACCESS_DENIED' | 'NOT_FOUND' | 'REVISION_REQUIRED' | 'REVISION_CHANGED' | 'UNSUPPORTED_PART' | 'IMAGE_UNAVAILABLE' | 'IMAGE_TOO_LARGE' | 'BUDGET_TOO_SMALL' | 'READ_FAILED' | 'TIMEOUT' | 'CANCELLED'
 /** Two sources claimed the same registry id. */
-'SOURCE_DUPLICATE'
+ | 'SOURCE_DUPLICATE'
 /** A reference named a source that is not registered. */
  | 'SOURCE_UNKNOWN'
 /** The owning source is registered but reported itself unusable. */

package/lib/host.d.ts

@@ -3,8 +3,50 @@ import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
 import type { ChatProvider, SettingsRecord } from './store/spec.ts';
 import type { SyncMode } from './sync/index.ts';
 import type { Agent } from '@deepseek-ai/dsh-agent';
+import { type LocalAgent } from './wire.ts';
+import type { AgentCandidate } from './client/remote.ts';
+declare module '@deepseek-ai/cordis' {
+    interface Context {
+        chatImport: {
+            readConversation?(input: {
+                format: string;
+                path: string;
+                sessionId?: string;
+                limit?: number;
+                before?: number;
+                revision?: string;
+                detail?: 'summary' | 'full';
+            }, signal?: AbortSignal): Promise<unknown>;
+            discoveryRoots?(): Record<string, string | string[] | null>;
+            scanDiscover(input: {
+                format?: string;
+                path?: string;
+                query?: string;
+            }, signal?: AbortSignal): Promise<unknown>;
+            importPath(input: {
+                format: string;
+                path: string;
+                sessionIds?: string[];
+            }, signal?: AbortSignal): Promise<unknown>;
+            resumeSummary(input: {
+                format: 'claude' | 'codex';
+                path: string;
+            }, signal?: AbortSignal): Promise<unknown>;
+        };
+    }
+}
 export declare class ReferenceAnythingRemote extends TypertRemoteService {
+    chatImportStatus(): Promise<import("./chat-import-compatibility.ts").ChatImportCompatibility>;
+    chatImportUpgradeInstall(signal: AbortSignal): Promise<import("./chat-import-compatibility.ts").ChatImportCompatibility>;
+    private readonly agentScans;
+    private readonly scannedTargets;
     constructor(ctx: Context);
+    agentResume(_agent: Agent, input: {
+        id: string;
+    }, signal: AbortSignal): Promise<string>;
+    agentImport(_agent: Agent, input: {
+        id: string;
+    }, signal: AbortSignal): Promise<string>;
     /**
      * Discovery for the `@` menu's local-agent group.
      *
@@ -17,18 +59,17 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
     agentSearch(agent: Agent, input: {
         query: string;
         limit: number;
-    }, signal: AbortSignal): Promise<{
-        searchIncomplete?: boolean | undefined;
-        updatedAt?: number | undefined;
-        id: string;
-        kind: string;
-        label: string;
-        provider: string;
-    }[]>;
+        kind?: LocalAgent;
+    }, signal: AbortSignal): Promise<AgentCandidate[]>;
     agentStats(signal: AbortSignal): Promise<{
-        agent: import("./sources/local-agent/types.ts").AgentKind;
+        readable: boolean;
+        paths?: string[];
+        agent: LocalAgent;
         conversations: number;
+        error?: string;
+        unavailable?: boolean;
     }[]>;
+    private assertScannedSelection;
     /**
      * Discovery for the `@` menu's cloud-drive group.
      *
@@ -86,10 +127,10 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
         historyMode: "metadata-only" | "offline-mirror";
         syncHistoryDays: number | null;
         enabledProviders: ("chatgpt" | "claude" | "gemini" | "deepseek" | "grok" | "kimi")[];
-        enabledAgents: ("kimi" | "claude-code" | "codex" | "cursor" | "qoder" | "reasonix" | "openclaw" | "grokbuild" | "hermes" | "gemini-cli" | "pi" | "opencode" | "mimocode" | "zcode")[];
+        enabledAgents: ("chatgpt" | "kimi" | "claude-code" | "codex" | "cursor" | "qoder" | "reasonix" | "openclaw" | "grokbuild" | "hermes" | "gemini-cli" | "pi" | "opencode" | "mimocode" | "zcode" | "antigravity" | "kilocode" | "workbuddy" | "qwen" | "continue" | "cline" | "goose" | "dsh4" | "zed" | "crush" | "teleagent" | "trae" | "vibe" | "dsh")[];
         maxReadTurns: number;
         inputRenderMode: "pill" | "raw-text";
-        agentDirectories?: Partial<Record<"kimi" | "claude-code" | "codex" | "cursor" | "qoder" | "reasonix" | "openclaw" | "grokbuild" | "hermes" | "gemini-cli" | "pi" | "opencode" | "mimocode" | "zcode", string>> | undefined;
+        agentDirectories?: Partial<Record<"chatgpt" | "kimi" | "claude-code" | "codex" | "cursor" | "qoder" | "reasonix" | "openclaw" | "grokbuild" | "hermes" | "gemini-cli" | "pi" | "opencode" | "mimocode" | "zcode" | "antigravity" | "kilocode" | "workbuddy" | "qwen" | "continue" | "cline" | "goose" | "dsh4" | "zed" | "crush" | "teleagent" | "trae" | "vibe" | "dsh", string>> | undefined;
         enabledDriveMounts?: string[] | undefined;
         picker?: {
             displayMode: "collapse" | "native-scroll";
@@ -98,42 +139,85 @@ 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;
+                showImport: boolean;
+                showSummary: boolean;
+                skipConfirmation: boolean;
+                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;
     }>;
@@ -197,4 +281,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;
+    }>[]>;
 }