dsh-reference-anything 0.2.5 → 0.3.0

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

@@ -192,31 +192,44 @@ export declare const referenceAnythingDomainSpec: {
                 pill: "pill";
                 "raw-text": "raw-text";
             }>>;
+            referenceUiMode: z.ZodOptional<z.ZodEnum<{
+                plugin: "plugin";
+                official: "official";
+            }>>;
             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>' },
@@ -17,6 +16,7 @@ export const TYPERT_MANIFEST = {
                     { kind: 'method', name: 'updateStatus', signature: 'updateStatus(signal: AbortSignal): Promise<PackageUpdateStatus>' },
                     { kind: 'method', name: 'checkUpdate', signature: 'checkUpdate(signal: AbortSignal): Promise<PackageUpdateStatus>' },
                     { kind: 'method', name: 'installUpdate', signature: 'installUpdate(signal: AbortSignal): Promise<PackageUpdateResult>' },
+                    { kind: 'method', name: 'switchReferenceUiMode', signature: 'switchReferenceUiMode(input: ReferenceUiModeInput, signal: AbortSignal): Promise<ReferenceUiSwitchResult>' },
                     { kind: 'method', name: 'stats', signature: 'stats(): ProviderStats[]' },
                     { kind: 'method', name: 'syncStart', signature: 'syncStart(input: SyncStart): string' },
                     { kind: 'method', name: 'syncStatus', signature: 'syncStatus(input: JobInput): SyncStatus | undefined' },

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(() => {

package/lib/wire.d.ts

@@ -22,41 +22,57 @@ declare const pickerSourceSettingsSchema: z.ZodObject<{
     enabled: z.ZodBoolean;
     order: z.ZodNumber;
     limit: z.ZodNumber;
+    maxCandidates: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type PickerSourceSettings = z.infer<typeof pickerSourceSettingsSchema>;
 export declare const pickerSettingsSchema: 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>;
 export type PickerSettings = z.infer<typeof pickerSettingsSchema>;
+export type PickerDisplayMode = PickerSettings['displayMode'];
 export declare const inputRenderModeSchema: z.ZodEnum<{
     pill: "pill";
     "raw-text": "raw-text";
 }>;
 export type InputRenderMode = z.infer<typeof inputRenderModeSchema>;
+export declare const referenceUiModeSchema: z.ZodEnum<{
+    plugin: "plugin";
+    official: "official";
+}>;
+export type ReferenceUiMode = z.infer<typeof referenceUiModeSchema>;
 /** Defaults used before the user saves the General section. */
 export declare function defaultPickerSettings(): PickerSettings;
 /** Picker settings have a fixed schema, so explicit comparison is cheap and stable. */
@@ -85,31 +101,44 @@ export declare const settingsRecordSchema: z.ZodObject<{
         pill: "pill";
         "raw-text": "raw-text";
     }>>;
+    referenceUiMode: z.ZodOptional<z.ZodEnum<{
+        plugin: "plugin";
+        official: "official";
+    }>>;
     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/wire.js

@@ -7,8 +7,10 @@ const pickerSourceSettingsSchema = z.object({
     enabled: z.boolean(),
     order: z.number().int().min(0).max(100),
     limit: z.number().int().min(1).max(50),
+    maxCandidates: z.number().int().min(1).max(50).default(50),
 });
 export const pickerSettingsSchema = z.object({
+    displayMode: z.enum(['collapse', 'native-scroll']).default('collapse'),
     commands: pickerSourceSettingsSchema,
     skills: pickerSourceSettingsSchema,
     files: pickerSourceSettingsSchema,
@@ -16,21 +18,26 @@ export const pickerSettingsSchema = z.object({
     conversations: pickerSourceSettingsSchema,
 });
 export const inputRenderModeSchema = z.enum(['pill', 'raw-text']);
+export const referenceUiModeSchema = z.enum(['plugin', 'official']);
 /** Defaults used before the user saves the General section. */
 export function defaultPickerSettings() {
     return {
-        commands: { enabled: true, order: 0, limit: 6 },
-        skills: { enabled: true, order: 5, limit: 6 },
-        files: { enabled: true, order: 10, limit: 6 },
-        sessions: { enabled: true, order: 20, limit: 6 },
-        conversations: { enabled: true, order: 30, limit: 6 },
+        displayMode: 'collapse',
+        commands: { enabled: true, order: 0, limit: 6, maxCandidates: 50 },
+        skills: { enabled: true, order: 5, limit: 6, maxCandidates: 50 },
+        files: { enabled: true, order: 10, limit: 6, maxCandidates: 50 },
+        sessions: { enabled: true, order: 20, limit: 6, maxCandidates: 50 },
+        conversations: { enabled: true, order: 30, limit: 6, maxCandidates: 50 },
     };
 }
 /** Picker settings have a fixed schema, so explicit comparison is cheap and stable. */
 export function samePickerSettings(left, right) {
-    return Object.keys(left).every(key => left[key].enabled === right[key].enabled &&
+    if (left.displayMode !== right.displayMode)
+        return false;
+    return pickerSourceSchema.options.every(key => left[key].enabled === right[key].enabled &&
         left[key].order === right[key].order &&
-        left[key].limit === right[key].limit);
+        left[key].limit === right[key].limit &&
+        left[key].maxCandidates === right[key].maxCandidates);
 }
 export const settingsRecordSchema = z.object({
     opencliPath: z.string(),
@@ -43,6 +50,8 @@ export const settingsRecordSchema = z.object({
     enabledProviders: z.array(providerSchema).default([...ALL_PROVIDERS]),
     maxReadTurns: z.number().int().min(1).max(100).default(10),
     inputRenderMode: inputRenderModeSchema.default('pill'),
+    // Optional keeps settings written by earlier plugin versions readable.
+    referenceUiMode: referenceUiModeSchema.optional(),
     // Optional keeps existing on-disk settings forward-compatible. The client
     // uses defaultPickerSettings() until the user saves the General section.
     picker: pickerSettingsSchema.optional(),

package/opencli-plugin/common.js

@@ -49,10 +49,54 @@ function assertResult(result, domain, operation) {
   return result.rows
 }
 
+const PROVIDER_READY_TIMEOUT_MS = 1200
+const PROVIDER_READY_INITIAL_DELAY_MS = 50
+const PROVIDER_READY_MAX_DELAY_MS = 400
+
+function terminalProviderResult(result) {
+  return result?.ok === true || result?.code === 'AUTH' || result?.code === 'RATE_LIMIT'
+}
+
+function terminalIdentityResult(result) {
+  return result?.code === 'AUTH' || result?.code === 'RATE_LIMIT'
+    || (result?.ok === true && typeof result.identity === 'string' && result.identity.length > 0)
+}
+
+/**
+ * Run the provider API as the readiness probe. The happy path performs one
+ * evaluate immediately after navigation; transient bootstrap failures retry
+ * with bounded exponential backoff instead of waiting for the whole SPA DOM
+ * to become quiet first.
+ */
+export async function evaluateWhenProviderReady(page, script, args, operation, options = {}) {
+  const timeoutMs = options.timeoutMs ?? PROVIDER_READY_TIMEOUT_MS
+  const maxDelayMs = options.maxDelayMs ?? PROVIDER_READY_MAX_DELAY_MS
+  const accepts = options.accepts ?? terminalProviderResult
+  const deadline = Date.now() + timeoutMs
+  let delayMs = options.initialDelayMs ?? PROVIDER_READY_INITIAL_DELAY_MS
+  let lastResult
+  let lastError
+  for (;;) {
+    try {
+      lastResult = await evaluate(page, script, args, operation)
+      lastError = undefined
+      if (accepts(lastResult)) return lastResult
+    } catch (error) {
+      lastError = error
+    }
+    const remaining = deadline - Date.now()
+    if (remaining <= 0) {
+      if (lastError) throw lastError
+      return lastResult
+    }
+    await new Promise(resolve => setTimeout(resolve, Math.min(delayMs, remaining)))
+    delayMs = Math.min(Math.max(delayMs * 2, 1), maxDelayMs)
+  }
+}
+
 /**
- * Close only the tab used by this adapter command. The persistent site session
- * prevents OpenCLI from sending its `close-window` lease-release action, while
- * Browser Bridge can keep and reuse the background container window.
+ * Each command owns an ephemeral Browser Bridge tab. Close that tab after the
+ * command finishes while preserving the provider result or failure.
  */
 async function inTemporaryTab(page, task) {
   try {
@@ -80,10 +124,12 @@ export function registerProvider(config) {
     ...browserSession,
     navigateBefore: false,
     args: [],
-    columns: ['identity'],
+    columns: ['identity'],
     func: async (page) => inTemporaryTab(page, async () => {
-      await page.goto(config.home, { settleMs: 500 })
-      const result = await evaluate(page, config.whoamiScript, {}, `${config.site} whoami`)
+      await page.goto(config.home, { waitUntil: 'none' })
+      const result = await evaluateWhenProviderReady(
+        page, config.whoamiScript, {}, `${config.site} whoami`, { accepts: terminalIdentityResult },
+      )
       if (result?.code === 'AUTH') throw new AuthRequiredError(config.domain)
       if (result?.ok !== true || typeof result.identity !== 'string' || !result.identity) {
         throw new CommandExecutionError(`${config.site} whoami: ${result?.message || 'stable account identity unavailable'}`)
@@ -110,8 +156,10 @@ export function registerProvider(config) {
     func: async (page, kwargs) => inTemporaryTab(page, async () => {
       const since = String(kwargs.since || '').trim()
       if (since && Number.isNaN(Date.parse(since))) throw new ArgumentError('since must be an ISO 8601 instant')
-      await page.goto(config.home, { settleMs: 1200 })
-      const identity = await evaluate(page, config.whoamiScript, {}, `${config.site} sync-index identity`)
+      await page.goto(config.home, { waitUntil: 'none' })
+      const identity = await evaluateWhenProviderReady(
+        page, config.whoamiScript, {}, `${config.site} sync-index identity`, { accepts: terminalIdentityResult },
+      )
       if (identity?.code === 'AUTH') throw new AuthRequiredError(config.domain)
       if (identity?.ok !== true || typeof identity.identity !== 'string' || !identity.identity) {
         throw new CommandExecutionError(`${config.site} sync-index: ${identity?.message || 'stable account identity unavailable'}`)
@@ -147,12 +195,12 @@ export function registerProvider(config) {
     columns: HISTORY_COLUMNS,
     func: async (page, kwargs) => inTemporaryTab(page, async () => {
       const since = String(kwargs.since || '').trim()
-      if (since && Number.isNaN(Date.parse(since))) throw new ArgumentError('since must be an ISO 8601 instant')
-      await page.goto(config.home, { settleMs: 1200 })
-      const rows = assertResult(
-        await evaluate(page, config.historyScript, { since }, `${config.site} history-all`),
-        config.domain,
-        `${config.site} history-all`,
+      if (since && Number.isNaN(Date.parse(since))) throw new ArgumentError('since must be an ISO 8601 instant')
+      await page.goto(config.home, { waitUntil: 'none' })
+      const rows = assertResult(
+        await evaluateWhenProviderReady(page, config.historyScript, { since }, `${config.site} history-all`),
+        config.domain,
+        `${config.site} history-all`,
       )
       return rows
     }),
@@ -247,16 +295,12 @@ export function registerProvider(config) {
         localPath: output,
       }]
     }),
-  })
+  })
 }
 
-/**
- * Keep one stable, background Browser Bridge session per provider site.
- * Persistence suppresses OpenCLI's `close-window` action; inTemporaryTab closes
- * only the finished command's tab so the reusable container window stays alive.
- */
+/** Browser Bridge lifecycle shared by every web-chat command. */
 export const SYNC_BROWSER_SESSION = Object.freeze({
-  siteSession: 'persistent',
+  siteSession: 'ephemeral',
   defaultWindowMode: 'background',
 })
 

package/opencli-plugin/opencli-plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-chat-history",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "opencli": ">=1.8.6",
   "description": "Full-history read adapters used by dsh-reference-anything"
 }

package/opencli-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencli-plugin-dsh-chat-history",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "peerDependencies": {
     "@jackwener/opencli": ">=1.8.6"