dsh-reference-anything 0.2.5 → 0.3.1

package/lib/contract.d.ts

@@ -1,18 +1,5 @@
 import { z } from 'zod';
 import type { InvocationDescriptor } from '@deepseek-ai/dsh-typert-protocol';
-export declare const workspaceEntrySchema: z.ZodReadonly<z.ZodObject<{
-    path: z.ZodString;
-    kind: z.ZodEnum<{
-        file: "file";
-        directory: "directory";
-    }>;
-}, z.core.$strip>>;
-export declare const sessionCandidateSchema: z.ZodReadonly<z.ZodObject<{
-    sessionId: z.ZodString;
-    label: z.ZodString;
-    cwd: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodNumber;
-}, z.core.$strip>>;
 export declare const searchInputSchema: z.ZodReadonly<z.ZodObject<{
     query: z.ZodString;
     provider: z.ZodOptional<z.ZodEnum<{
@@ -79,6 +66,7 @@ export declare const healthSchema: z.ZodReadonly<z.ZodObject<{
     daemonVersion: z.ZodOptional<z.ZodString>;
     daemonStale: z.ZodBoolean;
     connectivityOk: z.ZodBoolean;
+    connectivityChecked: z.ZodBoolean;
     pluginVersion: z.ZodOptional<z.ZodString>;
     adapterCommandsReady: z.ZodBoolean;
     adapterCompatible: z.ZodBoolean;

package/lib/contract.js

@@ -1,9 +1,5 @@
 import { z } from 'zod';
 import { providerSchema, settingsRecordSchema } from "./wire.js";
-export const workspaceEntrySchema = z.object({ path: z.string(), kind: z.enum(['file', 'directory']) }).readonly();
-export const sessionCandidateSchema = z.object({ sessionId: z.string(), label: z.string(), cwd: z.string().optional(), createdAt: z.number() }).readonly();
-const agentLookup = { name: 'agent', wire: 'agentId', source: 'lookup', lookup: 'agent',
-    codec: { mode: 'strict', typeSymbol: '@deepseek-ai/dsh-session/types#SessionId', schema: z.string().min(1) } };
 export const searchInputSchema = z.object({
     query: z.string(), provider: providerSchema.optional(), limit: z.number().int().min(1).max(100),
 }).readonly();
@@ -19,7 +15,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(), 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(),
     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();
@@ -72,10 +68,9 @@ export const providerSyncStateSchema = z.object({
     lastSyncAt: z.string(), lastCompleteScanAt: z.string(), error: z.string(),
 }).readonly();
 export const REFERENCE_ANYTHING_INVOCATIONS = [
-    descriptor('workspaceSearch', [agentLookup], strict('WorkspaceEntry[]', z.array(workspaceEntrySchema)), true),
-    descriptor('sessionSearch', [agentLookup, { name: 'input', wire: 'input', source: 'json', codec: strict('SessionSearchInput', z.object({ query: z.string(), limit: z.number().int().min(1).max(100) }).readonly()) }], strict('SessionCandidate[]', z.array(sessionCandidateSchema)), true),
     descriptor('search', [{ name: 'input', wire: 'input', source: 'json', codec: strict('SearchInput', searchInputSchema) }], strict('SearchResult[]', z.array(searchResultSchema)), true),
     descriptor('health', [], strict('Health', healthSchema), true),
+    descriptor('quickHealth', [], strict('Health', healthSchema), true),
     descriptor('profiles', [], strict('BrowserProfile[]', z.array(browserProfileSchema)), true),
     descriptor('discoverOpenCli', [], strict('OpenCliDiscovery', openCliDiscoverySchema), true),
     descriptor('installOpenCli', [], strict('OpenCliDiscovery', openCliDiscoverySchema), true),

package/lib/host.d.ts

@@ -2,25 +2,15 @@ import type { Context } from '@deepseek-ai/cordis';
 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';
 export declare class ReferenceAnythingRemote extends TypertRemoteService {
     constructor(ctx: Context);
-    workspaceSearch(agent: Agent, signal: AbortSignal): Promise<import("./workspace.ts").WorkspaceEntry[]>;
-    sessionSearch(agent: Agent, input: {
-        query: string;
-        limit: number;
-    }, signal: AbortSignal): Promise<{
-        sessionId: string;
-        label: string;
-        cwd?: string;
-        createdAt: number;
-    }[]>;
     search(input: {
         query: string;
         provider?: ChatProvider;
         limit: number;
     }, signal: AbortSignal): Promise<import("./sources/web-chat/index.ts").ConversationSearchResult[]>;
     health(signal: AbortSignal): Promise<import("./opencli.ts").OpenCliHealth>;
+    quickHealth(signal: AbortSignal): Promise<import("./opencli.ts").OpenCliHealth>;
     profiles(signal: AbortSignal): Promise<import("./opencli.ts").BrowserProfile[]>;
     discoverOpenCli(signal: AbortSignal): Promise<import("./opencli.ts").OpenCliDiscovery>;
     installOpenCli(signal: AbortSignal): Promise<import("./opencli.ts").OpenCliDiscovery>;
@@ -53,30 +43,36 @@ export declare class ReferenceAnythingRemote extends TypertRemoteService {
         maxReadTurns: number;
         inputRenderMode: "pill" | "raw-text";
         picker?: {
+            displayMode: "collapse" | "native-scroll";
             commands: {
                 enabled: boolean;
                 order: number;
                 limit: number;
+                maxCandidates: number;
             };
             skills: {
                 enabled: boolean;
                 order: number;
                 limit: number;
+                maxCandidates: number;
             };
             files: {
                 enabled: boolean;
                 order: number;
                 limit: number;
+                maxCandidates: number;
             };
             sessions: {
                 enabled: boolean;
                 order: number;
                 limit: number;
+                maxCandidates: number;
             };
             conversations: {
                 enabled: boolean;
                 order: number;
                 limit: number;
+                maxCandidates: number;
             };
         } | undefined;
     }>;

package/lib/host.js

@@ -1,18 +1,12 @@
 import { TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol';
-import { encodeSessionReferenceUri } from '@deepseek-ai/dsh-session-reference';
-import { indexWorkspace } from "./workspace.js";
 export class ReferenceAnythingRemote extends TypertRemoteService {
     constructor(ctx) { super(ctx, 'referenceAnything'); }
-    workspaceSearch(agent, signal) { return indexWorkspace(agent, signal); }
-    async sessionSearch(agent, input, signal) {
-        const rows = await this.ctx.sessionReferenceResolver.listCandidates(agent, input.query, input.limit, signal);
-        return rows.map(row => ({ ...row, sessionId: encodeSessionReferenceUri(row.sessionId) }));
-    }
     search(input, signal) {
         signal.throwIfAborted();
         return this.ctx.referenceChatHistory.search(input.query, input.provider, input.limit, signal);
     }
     health(signal) { return this.ctx.referenceChatHistory.health(signal); }
+    quickHealth(signal) { return this.ctx.referenceChatHistory.quickHealth(signal); }
     profiles(signal) { return this.ctx.referenceChatHistory.profiles(signal); }
     discoverOpenCli(signal) { return this.ctx.referenceChatHistory.discoverOpenCli(signal); }
     installOpenCli(signal) { return this.ctx.referenceChatHistory.installOpenCli(signal); }

package/lib/opencli.d.ts

@@ -1,7 +1,7 @@
 import type { ChatProvider } from './store/spec.ts';
 import type { ProviderConversationRow, ProviderTurnRow } from './store/store.ts';
 export declare const MIN_OPENCLI_VERSION = "1.8.6";
-export declare const MIN_ADAPTER_VERSION = "0.2.1";
+export declare const MIN_ADAPTER_VERSION = "0.2.2";
 export declare const OPENCLI_NPM_PACKAGE = "@jackwener/opencli";
 export type OpenCliErrorCode = 'EXTENSION_NOT_CONNECTED' | 'PROVIDER_TIMEOUT' | 'PROVIDER_NOT_LOGGED_IN' | 'PROVIDER_ACCOUNT_MISMATCH' | 'OPENCLI_CONFIGURATION' | 'OPENCLI_OUTPUT_TOO_LARGE' | 'OPENCLI_FAILED' | 'OPENCLI_INSTALL_FAILED';
 export declare class OpenCliError extends Error {
@@ -32,6 +32,7 @@ export interface OpenCliHealth {
     daemonVersion?: string;
     daemonStale: boolean;
     connectivityOk: boolean;
+    connectivityChecked: boolean;
     pluginVersion?: string;
     adapterCommandsReady: boolean;
     adapterCompatible: boolean;
@@ -96,6 +97,9 @@ export declare class OpenCliRunner {
     detail(provider: ChatProvider, id: string, signal?: AbortSignal, accountScope?: string): Promise<ProviderTurnRow[]>;
     attachment(provider: ChatProvider, locator: string, output: string, maxBytes: number, signal?: AbortSignal): Promise<Record<string, unknown>>;
     health(signal?: AbortSignal): Promise<OpenCliHealth>;
+    /** Inspect local OpenCLI, daemon, extension and plugin state without an active connectivity probe. */
+    quickHealth(signal?: AbortSignal): Promise<OpenCliHealth>;
+    private inspectHealth;
     /** Lightweight executable validation used by automatic path discovery. */
     version(signal?: AbortSignal): Promise<string>;
     /** Confirm the executable also exposes OpenCLI's plugin command, not merely a semver-looking --version. */

package/lib/opencli.js

@@ -5,7 +5,7 @@ import { promisify } from 'node:util';
 import { createHash } from 'node:crypto';
 const execFile = promisify(nodeExecFile);
 export const MIN_OPENCLI_VERSION = '1.8.6';
-export const MIN_ADAPTER_VERSION = '0.2.1';
+export const MIN_ADAPTER_VERSION = '0.2.2';
 export const OPENCLI_NPM_PACKAGE = '@jackwener/opencli';
 const SITE = {
     chatgpt: 'dsh-chatgpt', claude: 'dsh-claude', gemini: 'dsh-gemini',
@@ -13,13 +13,6 @@ const SITE = {
 };
 const REQUIRED_ADAPTER_COMMANDS = ['chatgpt', 'claude', 'gemini', 'deepseek', 'grok', 'kimi'];
 const ADAPTER_PLUGIN_NAME = 'dsh-chat-history';
-/**
- * A persistent OpenCLI site session owns one mutable browser lease. Serialize
- * commands that target the same executable/profile/site across runner
- * instances so concurrent detail workers cannot navigate or close each
- * other's active tab. Different provider sites still run in parallel.
- */
-const SITE_COMMAND_TAILS = new Map();
 export class OpenCliError extends Error {
     code;
     constructor(message, code, options) {
@@ -119,9 +112,16 @@ export class OpenCliRunner {
         return rows[0] ?? {};
     }
     async health(signal) {
+        return this.inspectHealth(true, signal);
+    }
+    /** Inspect local OpenCLI, daemon, extension and plugin state without an active connectivity probe. */
+    async quickHealth(signal) {
+        return this.inspectHealth(false, signal);
+    }
+    async inspectHealth(checkConnectivity, signal) {
         const [version, daemon, plugins, doctor] = await Promise.all([
             this.probe(['--version'], signal), this.probe(['daemon', 'status'], signal), this.probe(['plugin', 'list'], signal),
-            this.probe(['doctor'], signal),
+            checkConnectivity ? this.probe(['doctor'], signal) : Promise.resolve({ value: '', diagnostic: '' }),
         ]);
         const status = parseDaemonStatus(daemon.value);
         const cliVersion = normalizeVersion(version.value);
@@ -137,7 +137,7 @@ export class OpenCliRunner {
         return {
             version: cliVersion, daemon: daemon.value.trim(), pluginInstalled,
             daemonRunning: status.daemonRunning, extensionConnected: status.extensionConnected, extensionState: status.extensionState,
-            opencliCompatible, daemonStale, connectivityOk,
+            opencliCompatible, daemonStale, connectivityOk, connectivityChecked: checkConnectivity,
             ...(status.extensionVersion ? { extensionVersion: status.extensionVersion } : {}),
             ...(status.profileCount !== undefined ? { profileCount: status.profileCount } : {}),
             ...(daemonVersion ? { daemonVersion: normalizeVersion(daemonVersion) } : {}),
@@ -147,7 +147,7 @@ export class OpenCliRunner {
             ...(version.error ? { versionError: version.error } : {}),
             ...(daemon.error ? { daemonError: daemon.error } : {}),
             ...(plugins.error || adapterLoadError ? { pluginError: plugins.error || adapterLoadError } : {}),
-            ...(doctor.error ? { doctorError: doctor.error } : {}),
+            ...('error' in doctor && doctor.error ? { doctorError: doctor.error } : {}),
         };
     }
     /** Lightweight executable validation used by automatic path discovery. */
@@ -208,25 +208,21 @@ export class OpenCliRunner {
         }
     }
     async json(site, operation, args, signal) {
-        const queueKey = [this.executable, ...this.prefixArgs, this.profile, site].join('\0');
-        return serializeSiteCommand(queueKey, async () => {
-            // Pin adapter traffic to one persistent background session. Persistence
-            // suppresses OpenCLI's close-window action; the adapter closes only its
-            // completed task tab and leaves the background container reusable.
-            const stdout = await this.raw([
-                site, operation, ...args,
-                '--site-session', 'persistent', '--window', 'background', '-f', 'json',
-            ], signal);
-            try {
-                const parsed = JSON.parse(stdout);
-                if (!Array.isArray(parsed) || parsed.some(row => !row || typeof row !== 'object' || Array.isArray(row)))
-                    throw new Error('expected object array');
-                return parsed;
-            }
-            catch (error) {
-                throw new OpenCliError('OpenCLI returned malformed JSON', 'OPENCLI_CONFIGURATION', { cause: error });
-            }
-        });
+        // Match the sync-index lifecycle: every command gets its own temporary
+        // background tab, so providers and detail workers can run independently.
+        const stdout = await this.raw([
+            site, operation, ...args,
+            '--site-session', 'ephemeral', '--window', 'background', '-f', 'json',
+        ], signal);
+        try {
+            const parsed = JSON.parse(stdout);
+            if (!Array.isArray(parsed) || parsed.some(row => !row || typeof row !== 'object' || Array.isArray(row)))
+                throw new Error('expected object array');
+            return parsed;
+        }
+        catch (error) {
+            throw new OpenCliError('OpenCLI returned malformed JSON', 'OPENCLI_CONFIGURATION', { cause: error });
+        }
     }
     async raw(args, signal) {
         return (await this.command(args, signal)).stdout;
@@ -263,19 +259,6 @@ function adapterPluginLoadError(diagnostic = '') {
         .filter(line => /Plugin dsh-chat-history\//i.test(line));
     return [...new Set(lines)].join('\n').slice(0, 2_000);
 }
-async function serializeSiteCommand(key, task) {
-    const previous = SITE_COMMAND_TAILS.get(key) ?? Promise.resolve();
-    const current = previous.then(task, task);
-    const settled = current.then(() => undefined, () => undefined);
-    SITE_COMMAND_TAILS.set(key, settled);
-    try {
-        return await current;
-    }
-    finally {
-        if (SITE_COMMAND_TAILS.get(key) === settled)
-            SITE_COMMAND_TAILS.delete(key);
-    }
-}
 /** Locate a working OpenCLI without asking a command-line newcomer for PATH details. */
 export async function discoverOpenCli(configured = 'opencli', signal) {
     const candidates = openCliCandidates(configured);

package/lib/reference.d.ts

@@ -8,11 +8,9 @@
  * the loop durably appends, so injected material is logged by construction and
  * a replay reconstructs the request exactly.
  *
- * Two schemes are expanded. `dsh-ref:` names material outside the harness and
- * is resolved through `ctx.references`. `dsh-session:` names another harness
- * session and is delegated to `ctx.sessionReferenceResolver`, which owns
- * session-surface semantics — compaction folding, shadowed events, cited event
- * seqs — that do not generalize to an outside conversation.
+ * This plugin owns only `dsh-ref:`, which names material outside the harness
+ * and is resolved through `ctx.references`. Native file and DSH-session
+ * references are owned end-to-end by their official DSH services.
  *
  * @module dsh-reference-anything/reference
  */
@@ -32,12 +30,6 @@ export interface Config {
      * background, and the byte budget multiplies by the same factor.
      */
     maxReferences?: number;
-    /**
-     * Also expand `dsh-session:` mentions. Deployments that deliberately do not
-     * mount the cross-session resolver set this false, so such a mention is
-     * refused as unsupported rather than probed for on every message.
-     */
-    serveSessionScheme?: boolean;
 }
 /** Runtime schema for {@link Config}. */
 export declare const Config: z<Config>;

package/lib/reference.js

@@ -8,21 +8,17 @@
  * the loop durably appends, so injected material is logged by construction and
  * a replay reconstructs the request exactly.
  *
- * Two schemes are expanded. `dsh-ref:` names material outside the harness and
- * is resolved through `ctx.references`. `dsh-session:` names another harness
- * session and is delegated to `ctx.sessionReferenceResolver`, which owns
- * session-surface semantics — compaction folding, shadowed events, cited event
- * seqs — that do not generalize to an outside conversation.
+ * This plugin owns only `dsh-ref:`, which names material outside the harness
+ * and is resolved through `ctx.references`. Native file and DSH-session
+ * references are owned end-to-end by their official DSH services.
  *
  * @module dsh-reference-anything/reference
  */
 import z from '@deepseek-ai/schemastery';
 import { boundContextSummary, createUserMessage, freezeMessage } from '@deepseek-ai/dsh-llm';
-import { SESSION_REFERENCE_SCHEME, parseSessionReferenceText, } from '@deepseek-ai/dsh-session-reference';
 import { ReferenceAnythingError } from "./errors.js";
 import { renderDeferredReferences } from "./render.js";
 import { mayContainReference, parseReferenceText } from "./uri.js";
-import { WORKSPACE_REFERENCE_SCHEME, parseWorkspaceReferenceText, renderWorkspaceReferences } from "./workspace.js";
 /** Cordis plugin name used by loader diagnostics. */
 export const name = 'reference-mention';
 /** The registry this expander reads through. */
@@ -32,7 +28,6 @@ export const MAX_REFERENCES = 3;
 /** Runtime schema for {@link Config}. */
 export const Config = z.object({
     maxReferences: z.number().step(1).min(1).max(MAX_REFERENCES).default(MAX_REFERENCES),
-    serveSessionScheme: z.boolean().default(true),
 });
 /**
  * Register the pre-step mention expander.
@@ -41,7 +36,6 @@ export const Config = z.object({
  */
 export function apply(ctx, config = {}) {
     const maxReferences = Math.min(config.maxReferences ?? MAX_REFERENCES, MAX_REFERENCES);
-    const serveSessionScheme = config.serveSessionScheme ?? true;
     ctx.on('agent/pre-step', async ({ agent, signal }, next) => {
         const decision = await next();
         if (decision.kind === 'reject' || signal.aborted)
@@ -49,7 +43,7 @@ export function apply(ctx, config = {}) {
         // The overwhelmingly common case is a prompt with no mentions at all, and
         // this runs on every step of every turn. Screening with substring scans
         // before any parsing keeps that case free.
-        const target = decision.messages.findIndex(candidate => candidate.source.kind === 'user' && messageText(candidate).some(text => mentions(text, serveSessionScheme)));
+        const target = decision.messages.findIndex(candidate => candidate.source.kind === 'user' && messageText(candidate).some(mayContainReference));
         if (target < 0)
             return decision;
         const original = decision.messages[target];
@@ -57,7 +51,7 @@ export function apply(ctx, config = {}) {
             return decision;
         let parsed;
         try {
-            parsed = parseMessage(original, serveSessionScheme);
+            parsed = parseMessage(original);
         }
         catch (error) {
             // A malformed URI inside an explicit mention is the user asking for
@@ -65,11 +59,11 @@ export function apply(ctx, config = {}) {
             // reference silently resolves to nothing.
             return entered(decision, target, [notice(describe(error))], original);
         }
-        if (parsed.references.length === 0 && parsed.sessionReferences.length === 0 && parsed.workspaceReferences.length === 0)
+        if (parsed.references.length === 0)
             return decision;
         let contexts;
         try {
-            contexts = await resolve(ctx, agent, parsed, { maxReferences, serveSessionScheme }, signal);
+            contexts = await resolve(ctx, agent, parsed, maxReferences, signal);
         }
         catch (error) {
             if (signal.aborted)
@@ -85,28 +79,13 @@ export function apply(ctx, config = {}) {
  * Authorize and render the named references without reading their bodies.
  * The agent decides whether the current request warrants `reference_read`.
  */
-async function resolve(ctx, agent, parsed, limits, signal) {
+async function resolve(ctx, agent, parsed, maxReferences, signal) {
     const contexts = [];
-    if (parsed.workspaceReferences.length > 0) {
-        contexts.push(createUserMessage({
-            content: [{ type: 'text', text: await renderWorkspaceReferences(agent, parsed.workspaceReferences) }],
-            source: { kind: 'plugin', plugin: name, form: 'recall' },
-        }));
-    }
-    if (parsed.sessionReferences.length > 0) {
-        const resolver = ctx.get('sessionReferenceResolver');
-        if (resolver === undefined) {
-            throw new ReferenceAnythingError('this deployment cannot reference other harness sessions: the cross-session resolver is not mounted', 'SOURCE_UNAVAILABLE');
-        }
-        const prepared = await resolver.prepare(agent, contentOf(parsed.message), [...parsed.sessionReferences], signal);
-        if (prepared.additionalContext !== undefined)
-            contexts.push(prepared.additionalContext);
-    }
     if (parsed.references.length > 0) {
         const inputs = dedupe(parsed.references);
-        if (inputs.length > limits.maxReferences) {
-            throw new ReferenceAnythingError(`a message may reference at most ${limits.maxReferences} outside conversation`
-                + `${limits.maxReferences === 1 ? '' : 's'}; this one named ${inputs.length}`, 'REFERENCE_TOO_MANY');
+        if (inputs.length > maxReferences) {
+            throw new ReferenceAnythingError(`a message may reference at most ${maxReferences} outside conversation`
+                + `${maxReferences === 1 ? '' : 's'}; this one named ${inputs.length}`, 'REFERENCE_TOO_MANY');
         }
         for (const input of inputs)
             ctx.references.grant(String(agent.session.id), input.ref);
@@ -134,28 +113,16 @@ function entered(decision, target, contexts, message) {
     const replaced = decision.messages.with(target, message);
     return { kind: 'enter', messages: replaced.toSpliced(target, 0, ...contexts) };
 }
-/** Rewrite both schemes' mentions to readable text, preserving message identity. */
-function parseMessage(message, serveSessionScheme) {
+/** Rewrite external-conversation mentions to readable text, preserving message identity. */
+function parseMessage(message) {
     const references = [];
-    const sessionReferences = [];
-    const workspaceReferences = [];
     let changed = false;
     const content = message.content.map((block) => {
         if (block.type !== 'text')
             return block;
         const own = parseReferenceText(block.text);
         references.push(...own.references);
-        let text = own.text;
-        if (text.includes(WORKSPACE_REFERENCE_SCHEME)) {
-            const workspace = parseWorkspaceReferenceText(text);
-            workspaceReferences.push(...workspace.references);
-            text = workspace.text;
-        }
-        if (serveSessionScheme && text.includes(SESSION_REFERENCE_SCHEME)) {
-            const session = parseSessionReferenceText(text);
-            sessionReferences.push(...session.references);
-            text = session.text;
-        }
+        const text = own.text;
         if (text === block.text)
             return block;
         changed = true;
@@ -166,8 +133,6 @@ function parseMessage(message, serveSessionScheme) {
     return {
         message: changed ? freezeMessage({ ...message, content }) : message,
         references,
-        sessionReferences,
-        workspaceReferences,
     };
 }
 /** First-appearance order, one entry per distinct reference. */
@@ -183,15 +148,9 @@ function dedupe(references) {
     }
     return unique;
 }
-function mentions(text, serveSessionScheme) {
-    return mayContainReference(text) || text.includes(WORKSPACE_REFERENCE_SCHEME) || (serveSessionScheme && text.includes(SESSION_REFERENCE_SCHEME));
-}
 function messageText(message) {
     return message.content.flatMap(block => block.type === 'text' ? [block.text] : []);
 }
-function contentOf(message) {
-    return message.content.map(block => ({ ...block }));
-}
 function notice(summary) {
     return createUserMessage({
         content: [{

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

@@ -94,6 +94,7 @@ export default class WebChatHistoryService extends Service implements ReferenceS
     installOpenCli(signal?: AbortSignal): Promise<OpenCliDiscovery>;
     updateSettings(value: unknown): Promise<SettingsRecord>;
     health(signal?: AbortSignal): Promise<import("../../opencli.ts").OpenCliHealth>;
+    quickHealth(signal?: AbortSignal): Promise<import("../../opencli.ts").OpenCliHealth>;
     profiles(signal?: AbortSignal): Promise<import("../../opencli.ts").BrowserProfile[]>;
     private runner;
     installAdapter(signal?: AbortSignal): Promise<boolean>;

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

@@ -229,6 +229,11 @@ export default class WebChatHistoryService extends Service {
         return new OpenCliRunner({ executable: settings.opencliPath, profile: settings.profile,
             timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes }).health(signal);
     }
+    quickHealth(signal) {
+        const settings = this.store.settings;
+        return new OpenCliRunner({ executable: settings.opencliPath, profile: settings.profile,
+            timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes }).quickHealth(signal);
+    }
     profiles(signal) {
         const settings = this.store.settings;
         return new OpenCliRunner({ executable: settings.opencliPath, profile: '',

package/lib/store/spec.d.ts

@@ -193,30 +193,39 @@ export declare const referenceAnythingDomainSpec: {
                 "raw-text": "raw-text";
             }>>;
             picker: z.ZodOptional<z.ZodObject<{
+                displayMode: z.ZodDefault<z.ZodEnum<{
+                    collapse: "collapse";
+                    "native-scroll": "native-scroll";
+                }>>;
                 commands: z.ZodObject<{
                     enabled: z.ZodBoolean;
                     order: z.ZodNumber;
                     limit: z.ZodNumber;
+                    maxCandidates: z.ZodDefault<z.ZodNumber>;
                 }, z.core.$strip>;
                 skills: z.ZodObject<{
                     enabled: z.ZodBoolean;
                     order: z.ZodNumber;
                     limit: z.ZodNumber;
+                    maxCandidates: z.ZodDefault<z.ZodNumber>;
                 }, z.core.$strip>;
                 files: z.ZodObject<{
                     enabled: z.ZodBoolean;
                     order: z.ZodNumber;
                     limit: z.ZodNumber;
+                    maxCandidates: z.ZodDefault<z.ZodNumber>;
                 }, z.core.$strip>;
                 sessions: z.ZodObject<{
                     enabled: z.ZodBoolean;
                     order: z.ZodNumber;
                     limit: z.ZodNumber;
+                    maxCandidates: z.ZodDefault<z.ZodNumber>;
                 }, z.core.$strip>;
                 conversations: z.ZodObject<{
                     enabled: z.ZodBoolean;
                     order: z.ZodNumber;
                     limit: z.ZodNumber;
+                    maxCandidates: z.ZodDefault<z.ZodNumber>;
                 }, z.core.$strip>;
             }, z.core.$strip>>;
         }, z.core.$strip>;

package/lib/sync/index.js

@@ -109,9 +109,9 @@ export class ConversationSyncManager {
         const failures = new Map();
         let succeeded = 0;
         try {
-            await Promise.all(job.providers.map(async (provider) => {
+            for (const provider of job.providers) {
                 if (job.controller.signal.aborted)
-                    return;
+                    break;
                 const started = Date.now();
                 try {
                     await this.syncProvider(job, provider, mode, options);
@@ -123,11 +123,11 @@ export class ConversationSyncManager {
                     // logged-out account would otherwise permanently starve every
                     // provider after it in this list.
                     if (job.controller.signal.aborted)
-                        return;
+                        break;
                     failures.set(provider, describe(error));
                     this.logger?.warn(`reference sync: ${provider} failed: ${describe(error)}`);
                 }
-            }));
+            }
             job.status = job.controller.signal.aborted ? 'cancelled'
                 : failures.size === 0 ? 'complete'
                     : succeeded === 0 ? 'failed' : 'partial';

package/lib/typert.js

@@ -5,10 +5,9 @@ export const TYPERT_MANIFEST = {
                 key: 'referenceAnything', exportName: 'ReferenceAnythingRemote',
                 description: 'Local conversation mirror, synchronization, and settings for @Conversation.', tags: [],
                 members: [
-                    { kind: 'method', name: 'workspaceSearch', signature: 'workspaceSearch(agent: Agent, signal: AbortSignal): Promise<WorkspaceEntry[]>' },
-                    { kind: 'method', name: 'sessionSearch', signature: 'sessionSearch(agent: Agent, input: SessionSearchInput, signal: AbortSignal): Promise<SessionCandidate[]>' },
                     { kind: 'method', name: 'search', signature: 'search(input: SearchInput): Promise<SearchResult[]>' },
                     { kind: 'method', name: 'health', signature: 'health(signal: AbortSignal): Promise<Health>' },
+                    { kind: 'method', name: 'quickHealth', signature: 'quickHealth(signal: AbortSignal): Promise<Health>' },
                     { kind: 'method', name: 'profiles', signature: 'profiles(signal: AbortSignal): Promise<BrowserProfile[]>' },
                     { kind: 'method', name: 'discoverOpenCli', signature: 'discoverOpenCli(signal: AbortSignal): Promise<OpenCliDiscovery>' },
                     { kind: 'method', name: 'installOpenCli', signature: 'installOpenCli(signal: AbortSignal): Promise<OpenCliDiscovery>' },

package/lib/web.js

@@ -1,7 +1,7 @@
 import { ReferenceAnythingRemote } from "./host.js";
 import { TYPERT_MANIFEST } from "./typert.js";
 export const name = 'reference-anything-web';
-export const inject = ['typert', 'referenceChatHistory', 'sessionReferenceResolver'];
+export const inject = ['typert', 'referenceChatHistory'];
 export function apply(ctx) {
     new ReferenceAnythingRemote(ctx);
     ctx.effect(() => {