dsh-reference-anything 0.2.4 → 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

@@ -38,7 +38,7 @@ async function evaluate(page, script, args, operation) {
   return parseEvaluate(await page.evaluate(source), operation)
 }
 
-function assertResult(result, domain, operation) {
+function assertResult(result, domain, operation) {
   if (result?.code === 'AUTH') throw new AuthRequiredError(domain, result.message || `${operation} requires login`)
   if (result?.code === 'RATE_LIMIT') {
     throw new CommandExecutionError(`${operation}: ${result.message || 'provider rate limit reached'}`)
@@ -46,9 +46,70 @@ function assertResult(result, domain, operation) {
   if (result?.ok !== true || !Array.isArray(result.rows)) {
     throw new CommandExecutionError(`${operation}: ${result?.message || 'provider adapter did not return rows'}`)
   }
-  return result.rows
-}
-
+  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)
+  }
+}
+
+/**
+ * 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 {
+    return await task()
+  } finally {
+    try {
+      await page.closeTab?.()
+    } catch {
+      // Preserve the provider result/error if the tab or browser closed first.
+    }
+  }
+}
+
 export function registerProvider(config) {
   const browserSession = SYNC_BROWSER_SESSION
 
@@ -63,16 +124,18 @@ export function registerProvider(config) {
     ...browserSession,
     navigateBefore: false,
     args: [],
-    columns: ['identity'],
-    func: async (page) => {
-      await page.goto(config.home, { settleMs: 500 })
-      const result = await evaluate(page, config.whoamiScript, {}, `${config.site} whoami`)
+    columns: ['identity'],
+    func: async (page) => inTemporaryTab(page, async () => {
+      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'}`)
       }
       return [{ identity: result.identity }]
-    },
+    }),
   })
 
   cli({
@@ -90,11 +153,13 @@ export function registerProvider(config) {
       help: 'ISO 8601 instant; stop paging once the listing predates it. Honoured only while the provider pages newest-first',
     }, { name: 'accountScope', help: 'Previously observed hashed account scope; mismatch forces a full listing' }],
     columns: SYNC_INDEX_COLUMNS,
-    func: async (page, kwargs) => {
+    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'}`)
@@ -110,7 +175,7 @@ export function registerProvider(config) {
         { kind: 'identity', identity: identity.identity, sinceApplied: effectiveSince },
         ...rows.map(row => ({ kind: 'conversation', identity: '', sinceApplied: '', ...row })),
       ]
-    },
+    }),
   })
 
   cli({
@@ -128,17 +193,17 @@ export function registerProvider(config) {
       help: 'ISO 8601 instant; stop paging once the listing predates it. Honoured only while the provider pages newest-first',
     }],
     columns: HISTORY_COLUMNS,
-    func: async (page, kwargs) => {
+    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
-    },
+    }),
   })
 
   cli({
@@ -156,7 +221,7 @@ export function registerProvider(config) {
       { name: 'accountScope', help: 'Expected hashed account scope; mismatch refuses the read' },
     ],
     columns: DETAIL_COLUMNS,
-    func: async (page, kwargs) => {
+    func: async (page, kwargs) => inTemporaryTab(page, async () => {
       const id = String(kwargs.id || '').trim()
       if (!id) throw new ArgumentError('id must be a non-empty conversation id')
       await page.goto(config.home, { settleMs: 600 })
@@ -180,7 +245,7 @@ export function registerProvider(config) {
       const rows = assertResult(result, config.domain, `${config.site} detail`)
       if (rows.length === 0) throw new EmptyResultError(`${config.site} detail`, `No messages found for ${id}`)
       return rows
-    },
+    }),
   })
 
   cli({
@@ -199,7 +264,7 @@ export function registerProvider(config) {
       { name: 'maxBytes', type: 'int', default: 26214400, help: 'Maximum decoded bytes' },
     ],
     columns: ['attachmentId', 'name', 'mimeType', 'size', 'status', 'localPath'],
-    func: async (page, kwargs) => {
+    func: async (page, kwargs) => inTemporaryTab(page, async () => {
       const locator = String(kwargs.locator || '').trim()
       const output = resolve(String(kwargs.output || ''))
       const maxBytes = Number(kwargs.maxBytes ?? 26_214_400)
@@ -229,18 +294,13 @@ export function registerProvider(config) {
         status: 'available',
         localPath: output,
       }]
-    },
-  })
+    }),
+  })
 }
 
-/**
- * Keep one stable, background Browser Bridge session per provider site.
- * OpenCLI maps persistent sessions to `site:<config.site>` and keeps their tab
- * lease after both successful and failed commands, so later sync work reuses
- * the same tab. If the user closes it manually, OpenCLI recreates it on demand.
- */
+/** 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"
 }