dsh-reference-anything 0.2.0

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

@@ -0,0 +1,359 @@
+import { Context, Service } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { providerSchema, referenceAnythingDomainSpec, settingsRecordSchema } from "../../store/spec.js";
+import { ConversationStore } from "../../store/store.js";
+import { ConversationSyncManager } from "../../sync/index.js";
+import { OpenCliError, OpenCliRunner, discoverOpenCli, installOpenCli as installOpenCliPackage } from "../../opencli.js";
+import { ReferenceAnythingError } from "../../errors.js";
+import { parseProviderQuery } from "../../search.js";
+export { parseProviderQuery };
+export const name = 'reference-web-chat';
+export const inject = ['references', 'storageDomain'];
+/** Window a catch-up pass waits in after arming, so it misses the startup rush. */
+const CATCH_UP_MIN_MS = 30_000;
+const CATCH_UP_MAX_MS = 90_000;
+export const Config = z.object({
+    timeoutMs: z.number().step(1).min(1_000).default(60_000),
+    maxStdoutBytes: z.number().step(1).min(65_536).default(32 * 1024 * 1024),
+});
+const PROVIDERS = ['chatgpt', 'claude', 'gemini', 'deepseek', 'grok', 'kimi'];
+export default class WebChatHistoryService extends Service {
+    config;
+    static inject = inject;
+    static Config = Config;
+    id = 'web-chat';
+    storeValue;
+    syncValue;
+    autoSyncInterval;
+    autoSyncCatchUp;
+    liveAttachments = new Map();
+    constructor(ctx, config = {}) {
+        super(ctx, 'referenceChatHistory');
+        this.config = config;
+    }
+    async [Service.init]() {
+        const domain = await this.ctx.storageDomain.open(referenceAnythingDomainSpec);
+        this.ctx.effect(() => () => domain.close(), 'reference-web-chat.domainClose');
+        this.storeValue = new ConversationStore(domain);
+        // The schema default also applies to installations created before modes
+        // existed. Enforce that default immediately so legacy mirrored bodies do
+        // not survive silently under a metadata-only setting.
+        if (this.store.settings.historyMode === 'metadata-only') {
+            await this.store.setSettings(this.store.settings);
+            await this.store.clearMirrorContent();
+        }
+        this.syncValue = new ConversationSyncManager(this.storeValue, () => new OpenCliRunner({
+            executable: this.store.settings.opencliPath, profile: this.store.settings.profile,
+            timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes,
+        }), this.ctx.logger);
+        await this.store.collectExpired();
+        this.ctx.references.registerSource(this);
+        this.ctx.effect(() => () => { this.clearAutoSync(); }, 'reference-web-chat.autoSyncCleanup');
+        this.armAutoSync();
+    }
+    get store() {
+        if (!this.storeValue)
+            throw new Error('Web chat history service is not initialized');
+        return this.storeValue;
+    }
+    get sync() {
+        if (!this.syncValue)
+            throw new Error('Web chat history service is not initialized');
+        return this.syncValue;
+    }
+    async available() { return this.storeValue !== undefined; }
+    async list(query, limit) {
+        const parsed = parseProviderQuery(query);
+        // No excerpt here: this surface feeds the model, and mirrored conversation
+        // text may only reach it inside `reference_read`'s untrusted-data envelope.
+        return this.store.list(parsed.query, parsed.provider, limit).map(({ key, row }) => ({
+            ref: { source: this.id, id: key }, label: row.title, origin: row.url,
+            updatedAt: timestamp(row.updatedAt), provider: row.provider,
+            messageCount: row.messageCount, partial: row.partial, syncedAt: timestamp(row.syncedAt),
+        }));
+    }
+    async read(ref, window, signal) {
+        if (ref.source !== this.id)
+            throw new Error(`web-chat cannot read source ${ref.source}`);
+        if (this.store.settings.historyMode === 'metadata-only')
+            return this.readRemote(ref.id, window, signal);
+        return this.store.read(ref.id, window);
+    }
+    /** Resolve an attachment locator captured by a recent metadata-only read. Never persisted. */
+    liveAttachment(conversationKey, attachmentId) {
+        const key = `${conversationKey}\0${attachmentId}`;
+        const hit = this.liveAttachments.get(key);
+        if (!hit || hit.expiresAt <= Date.now()) {
+            this.liveAttachments.delete(key);
+            return undefined;
+        }
+        return hit.attachment;
+    }
+    async readRemote(conversationKey, window, signal) {
+        const conversation = this.store.conversations.get(conversationKey);
+        if (!conversation || conversation.remoteMissing) {
+            throw new ReferenceAnythingError('conversation is missing from the local active-account index; ask the user to sync its provider and reselect it from the refreshed @ list, then retry', 'REFERENCE_NOT_FOUND');
+        }
+        let end = window.before;
+        if (window.cursor !== undefined)
+            end = decodeLiveCursor(window.cursor, conversationKey);
+        let rows;
+        try {
+            rows = await this.runner().detail(conversation.provider, conversation.externalId, signal, conversation.accountScope);
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw signal.reason;
+            if (error instanceof OpenCliError && error.code === 'PROVIDER_ACCOUNT_MISMATCH') {
+                throw new ReferenceAnythingError(`conversation belongs to a different logged-in ${conversation.provider} account; ask the user to sync ${conversation.provider} and reselect it from the refreshed @ list, then retry`, 'REFERENCE_ACCOUNT_MISMATCH', { cause: error });
+            }
+            throw new ReferenceAnythingError(`could not fetch the conversation from ${conversation.provider}; ask the user to confirm the browser connection and login, sync ${conversation.provider}, and then retry`, 'REFERENCE_READ_FAILED', { cause: error });
+        }
+        const turns = projectRemoteTurns(rows);
+        const boundedEnd = Math.max(0, Math.min(end ?? turns.length, turns.length));
+        const start = Math.max(0, boundedEnd - Math.max(1, Math.trunc(window.limit)));
+        const expiresAt = Date.now() + 60 * 60_000;
+        for (const turn of turns.slice(start, boundedEnd))
+            for (const attachment of turn.attachments ?? []) {
+                this.liveAttachments.set(`${conversationKey}\0${attachment.attachmentId}`, { attachment, expiresAt });
+            }
+        const nextCursor = start > 0 ? encodeLiveCursor(conversationKey, start) : undefined;
+        return {
+            ref: { source: this.id, id: conversationKey }, label: conversation.title, origin: conversation.url,
+            updatedAt: timestamp(conversation.updatedAt), provider: conversation.provider,
+            partial: conversation.partial || rows.some(row => row.partial), capturedAt: Date.now(),
+            body: {
+                kind: 'conversation', items: turns.slice(start, boundedEnd), startIndex: start,
+                totalTurns: turns.length, hasOlder: start > 0, ...(nextCursor ? { nextCursor } : {}),
+            },
+        };
+    }
+    async search(query, provider, limit, signal) {
+        signal?.throwIfAborted();
+        const parsed = parseProviderQuery(query);
+        return this.store
+            .list(parsed.query, provider ?? parsed.provider, Math.max(1, Math.min(100, limit)))
+            .map(({ key, row, via, snippet }) => ({
+            uriId: key, provider: row.provider, title: row.title, url: row.url, updatedAt: row.updatedAt,
+            turnCount: row.messageCount, partial: row.partial, syncedAt: row.syncedAt,
+            matchedVia: via, ...(snippet ? { snippet } : {}),
+        }));
+    }
+    stats() { return this.store.stats(PROVIDERS); }
+    storageStats() { return this.store.storageStats(); }
+    /** Paginated browse for the management list — unlike {@link search}, includes `remoteMissing` rows. */
+    browse(query, provider, limit, offset) {
+        const { items, total } = this.store.page(query, provider, Math.max(1, Math.min(100, limit)), Math.max(0, offset));
+        return {
+            total,
+            items: items.map(([uriId, row]) => ({
+                uriId, provider: row.provider, title: row.title, url: row.url, updatedAt: row.updatedAt,
+                turnCount: row.messageCount, partial: row.partial, syncedAt: row.syncedAt, remoteMissing: row.remoteMissing,
+            })),
+        };
+    }
+    /** Permanently delete a synced conversation; refused while a sync could resurrect it mid-delete. */
+    async remove(uriId) {
+        if (this.sync.isRunning()) {
+            throw new ReferenceAnythingError('cannot delete a conversation while a sync is in progress', 'REFERENCE_SYNC_IN_PROGRESS');
+        }
+        return this.store.remove(uriId);
+    }
+    async removeProvider(provider) {
+        if (this.sync.isRunning())
+            throw new ReferenceAnythingError('cannot clear provider data while a sync is in progress', 'REFERENCE_SYNC_IN_PROGRESS');
+        return this.store.removeProvider(provider);
+    }
+    async removeOlderThan(days) {
+        if (this.sync.isRunning())
+            throw new ReferenceAnythingError('cannot clear old data while a sync is in progress', 'REFERENCE_SYNC_IN_PROGRESS');
+        return this.store.removeOlderThan(days);
+    }
+    async removeRemoteMissing() {
+        if (this.sync.isRunning())
+            throw new ReferenceAnythingError('cannot clear remote-missing data while a sync is in progress', 'REFERENCE_SYNC_IN_PROGRESS');
+        return this.store.removeRemoteMissing();
+    }
+    async removeOldAccounts() {
+        if (this.sync.isRunning())
+            throw new ReferenceAnythingError('cannot clear old-account data while a sync is in progress', 'REFERENCE_SYNC_IN_PROGRESS');
+        return this.store.removeOldAccounts();
+    }
+    /** Durable per-provider sync status, independent of any single in-flight job. */
+    syncStates() { return this.store.syncStateSummary(); }
+    getSettings() { return this.store.settings; }
+    async restartDaemon(signal) { await this.runner().restartDaemon(signal); return true; }
+    async discoverOpenCli(signal) {
+        return discoverOpenCli(this.store.settings.opencliPath, signal);
+    }
+    async installOpenCli(signal) {
+        const discovery = await installOpenCliPackage(signal);
+        if (this.store.settings.opencliPath !== discovery.executable) {
+            await this.store.setSettings({ ...this.store.settings, opencliPath: discovery.executable });
+        }
+        return discovery;
+    }
+    async updateSettings(value) {
+        const settings = settingsRecordSchema.parse(value);
+        const enteringMetadataOnly = settings.historyMode === 'metadata-only' && this.store.settings.historyMode !== 'metadata-only';
+        await this.store.setSettings(settings);
+        if (enteringMetadataOnly)
+            await this.store.clearMirrorContent();
+        this.armAutoSync();
+        return settings;
+    }
+    health(signal) {
+        const settings = this.store.settings;
+        return new OpenCliRunner({ executable: settings.opencliPath, profile: settings.profile,
+            timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes }).health(signal);
+    }
+    profiles(signal) {
+        const settings = this.store.settings;
+        return new OpenCliRunner({ executable: settings.opencliPath, profile: '',
+            timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes }).profiles(signal);
+    }
+    runner() {
+        const settings = this.store.settings;
+        return new OpenCliRunner({ executable: settings.opencliPath, profile: settings.profile,
+            timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes });
+    }
+    async installAdapter(signal) {
+        const settings = this.store.settings;
+        const runner = new OpenCliRunner({ executable: settings.opencliPath, profile: settings.profile,
+            timeoutMs: this.config.timeoutMs, maxStdoutBytes: this.config.maxStdoutBytes });
+        await runner.installPlugin(new URL('../../../opencli-plugin/', import.meta.url).href, signal);
+        return true;
+    }
+    /**
+     * (Re)arm the background sync timer from the current settings.
+     *
+     * Clears its own timers rather than swapping a `ctx.effect` disposer:
+     * disposing is asynchronous, so re-arming through it left a window — one
+     * that a couple of quick settings saves is enough to hit — where two
+     * intervals were live at once.
+     */
+    armAutoSync() {
+        this.clearAutoSync();
+        const settings = this.store.settings;
+        if (!settings.autoSync && !settings.syncOnStartup)
+            return;
+        const period = settings.autoSyncMinutes * 60_000;
+        const tick = () => {
+            if (this.sync.isRunning()) {
+                this.ctx.logger.info('reference sync: skipping the auto-sync tick, a sync is still running');
+                return;
+            }
+            const providers = this.sync.eligibleProviders(settings.enabledProviders);
+            if (providers.length === 0) {
+                this.ctx.logger.info('reference sync: no provider is eligible for auto-sync right now');
+                return;
+            }
+            this.ctx.logger.info(`reference sync: auto-syncing ${providers.join(', ')}`);
+            this.sync.start(providers, 'incremental', {
+                // The tick's own gate is `isRunning`, so a job that never finishes
+                // would silently cancel every later tick.
+                deadlineMs: period * 2,
+            });
+        };
+        // Jitter keeps every provider — and every dsh instance sharing a default
+        // interval — off the same instant.
+        if (settings.autoSync) {
+            this.autoSyncInterval = setInterval(tick, jitter(period));
+            this.autoSyncInterval.unref?.();
+        }
+        const delay = this.catchUpDelay(period);
+        if (delay !== undefined) {
+            this.autoSyncCatchUp = setTimeout(tick, delay);
+            this.autoSyncCatchUp.unref?.();
+        }
+    }
+    /**
+     * How long to wait before a catch-up pass, or undefined when the last one
+     * is recent enough that the regular interval will do.
+     *
+     * A plain interval only ever fires a full period after arming, so enabling
+     * background sync — or restarting dsh after a day off — used to mean the
+     * mirror stayed stale for up to a day before anything happened.
+     */
+    catchUpDelay(period) {
+        let newest = 0;
+        for (const [, row] of this.store.syncStates.entries()) {
+            const at = Date.parse(row.lastSyncAt || '');
+            if (!Number.isNaN(at) && at > newest)
+                newest = at;
+        }
+        const elapsed = Date.now() - newest;
+        if (newest > 0 && elapsed < period)
+            return undefined;
+        // Not immediately: startup is already the busiest moment in the process,
+        // and nothing here is urgent to the second.
+        return CATCH_UP_MIN_MS + Math.random() * (CATCH_UP_MAX_MS - CATCH_UP_MIN_MS);
+    }
+    clearAutoSync() {
+        if (this.autoSyncInterval) {
+            clearInterval(this.autoSyncInterval);
+            this.autoSyncInterval = undefined;
+        }
+        if (this.autoSyncCatchUp) {
+            clearTimeout(this.autoSyncCatchUp);
+            this.autoSyncCatchUp = undefined;
+        }
+    }
+}
+/** Spread a period by ±10% so providers and instances do not all fire together. */
+function jitter(period) {
+    return Math.round(period * (0.9 + Math.random() * 0.2));
+}
+function timestamp(value) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric) && value.trim())
+        return numeric < 10_000_000_000 ? numeric * 1_000 : numeric;
+    const parsed = Date.parse(value);
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function projectRemoteTurns(rows) {
+    return rows.filter(row => row.activeBranch !== false).sort((a, b) => a.ordinal - b.ordinal).flatMap(row => {
+        const attachments = parseLiveAttachments(row.attachmentsJson);
+        const text = String(row.text || '');
+        if (!text.trim() && attachments.length === 0)
+            return [];
+        return [{ role: row.role, text, ...(attachments.length ? { attachments } : {}) }];
+    });
+}
+function parseLiveAttachments(raw) {
+    try {
+        const parsed = JSON.parse(raw || '[]');
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.map((value, index) => {
+            const row = value && typeof value === 'object' ? value : {};
+            const name = String(row.name ?? 'attachment');
+            const mimeType = String(row.mimeType ?? '');
+            const locator = typeof row.locator === 'string' && row.locator ? row.locator : undefined;
+            const status = row.status === 'available' || row.status === 'expired' ? row.status : 'unavailable';
+            return {
+                attachmentId: String(row.attachmentId ?? row.id ?? index),
+                kind: row.kind === 'image' || row.type === 'image' || mimeType.startsWith('image/') ? 'image' : 'file',
+                name, mimeType, size: Math.max(0, Number(row.size ?? 0) || 0), status,
+                ...(locator ? { locator } : {}),
+            };
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function encodeLiveCursor(ref, nextOrdinal) {
+    return Buffer.from(JSON.stringify({ v: 2, ref, nextOrdinal })).toString('base64url');
+}
+function decodeLiveCursor(value, expectedRef) {
+    try {
+        const row = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (row.v !== 2 || row.ref !== expectedRef || !Number.isInteger(row.nextOrdinal) || Number(row.nextOrdinal) < 0)
+            throw new Error();
+        return Number(row.nextOrdinal);
+    }
+    catch {
+        throw new ReferenceAnythingError('live reference cursor is malformed or belongs to another conversation', 'REFERENCE_INVALID_CURSOR');
+    }
+}

package/lib/store/spec.d.ts

@@ -0,0 +1,312 @@
+import { z } from 'zod';
+import { providerSchema, settingsRecordSchema } from '../wire.ts';
+import type { ChatProvider, SettingsRecord } from '../wire.ts';
+export { providerSchema, settingsRecordSchema };
+export type { ChatProvider, SettingsRecord };
+export declare const storedAttachmentSchema: z.ZodObject<{
+    attachmentId: z.ZodString;
+    kind: z.ZodDefault<z.ZodEnum<{
+        file: "file";
+        image: "image";
+    }>>;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    size: z.ZodNumber;
+    status: z.ZodEnum<{
+        available: "available";
+        unavailable: "unavailable";
+        expired: "expired";
+    }>;
+    locator: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type StoredAttachment = z.infer<typeof storedAttachmentSchema>;
+export declare const storedTurnSchema: z.ZodObject<{
+    ordinal: z.ZodNumber;
+    messageId: z.ZodString;
+    parentId: z.ZodString;
+    branchId: z.ZodString;
+    role: z.ZodEnum<{
+        user: "user";
+        assistant: "assistant";
+    }>;
+    text: z.ZodString;
+    createdAt: z.ZodString;
+    attachments: z.ZodArray<z.ZodObject<{
+        attachmentId: z.ZodString;
+        kind: z.ZodDefault<z.ZodEnum<{
+            file: "file";
+            image: "image";
+        }>>;
+        name: z.ZodString;
+        mimeType: z.ZodString;
+        size: z.ZodNumber;
+        status: z.ZodEnum<{
+            available: "available";
+            unavailable: "unavailable";
+            expired: "expired";
+        }>;
+        locator: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type StoredTurn = z.infer<typeof storedTurnSchema>;
+export declare const conversationRecordSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>;
+    accountScope: z.ZodString;
+    externalId: z.ZodString;
+    title: z.ZodString;
+    url: z.ZodString;
+    currentRevision: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    messageCount: z.ZodNumber;
+    partial: z.ZodBoolean;
+    remoteMissing: z.ZodBoolean;
+    syncedAt: z.ZodString;
+}, z.core.$strip>;
+export type ConversationRecord = z.infer<typeof conversationRecordSchema>;
+export declare const revisionRecordSchema: z.ZodObject<{
+    conversationKey: z.ZodString;
+    revision: z.ZodString;
+    contentHash: z.ZodString;
+    turnCount: z.ZodNumber;
+    activeBranch: z.ZodString;
+    chunkKeys: z.ZodArray<z.ZodString>;
+    partial: z.ZodBoolean;
+    syncedAt: z.ZodString;
+    expiresAt: z.ZodString;
+}, z.core.$strip>;
+export type RevisionRecord = z.infer<typeof revisionRecordSchema>;
+export declare const turnChunkRecordSchema: z.ZodObject<{
+    conversationKey: z.ZodString;
+    revision: z.ZodString;
+    index: z.ZodNumber;
+    turns: z.ZodArray<z.ZodObject<{
+        ordinal: z.ZodNumber;
+        messageId: z.ZodString;
+        parentId: z.ZodString;
+        branchId: z.ZodString;
+        role: z.ZodEnum<{
+            user: "user";
+            assistant: "assistant";
+        }>;
+        text: z.ZodString;
+        createdAt: z.ZodString;
+        attachments: z.ZodArray<z.ZodObject<{
+            attachmentId: z.ZodString;
+            kind: z.ZodDefault<z.ZodEnum<{
+                file: "file";
+                image: "image";
+            }>>;
+            name: z.ZodString;
+            mimeType: z.ZodString;
+            size: z.ZodNumber;
+            status: z.ZodEnum<{
+                available: "available";
+                unavailable: "unavailable";
+                expired: "expired";
+            }>;
+            locator: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type TurnChunkRecord = z.infer<typeof turnChunkRecordSchema>;
+export declare const attachmentRecordSchema: z.ZodObject<{
+    attachmentId: z.ZodString;
+    kind: z.ZodDefault<z.ZodEnum<{
+        file: "file";
+        image: "image";
+    }>>;
+    name: z.ZodString;
+    mimeType: z.ZodString;
+    size: z.ZodNumber;
+    status: z.ZodEnum<{
+        available: "available";
+        unavailable: "unavailable";
+        expired: "expired";
+    }>;
+    locator: z.ZodOptional<z.ZodString>;
+    conversationKey: z.ZodString;
+    revision: z.ZodString;
+    ordinal: z.ZodNumber;
+}, z.core.$strip>;
+export type AttachmentRecord = z.infer<typeof attachmentRecordSchema>;
+export declare const syncStateRecordSchema: z.ZodObject<{
+    provider: z.ZodEnum<{
+        chatgpt: "chatgpt";
+        claude: "claude";
+        gemini: "gemini";
+        deepseek: "deepseek";
+        grok: "grok";
+        kimi: "kimi";
+    }>;
+    profile: z.ZodString;
+    accountScope: z.ZodString;
+    cursor: z.ZodString;
+    status: z.ZodEnum<{
+        failed: "failed";
+        cancelled: "cancelled";
+        running: "running";
+        idle: "idle";
+    }>;
+    lastSyncAt: z.ZodString;
+    lastCompleteScanAt: z.ZodString;
+    error: z.ZodString;
+    completed: z.ZodNumber;
+    total: z.ZodNumber;
+    consecutiveFailures: z.ZodDefault<z.ZodNumber>;
+    nextEligibleAt: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+export type SyncStateRecord = z.infer<typeof syncStateRecordSchema>;
+export declare const referenceAnythingDomainSpec: {
+    name: string;
+    version: number;
+    global: {
+        schema: z.ZodObject<{
+            opencliPath: z.ZodString;
+            profile: z.ZodString;
+            detailConcurrency: z.ZodNumber;
+            autoSync: z.ZodDefault<z.ZodBoolean>;
+            syncOnStartup: z.ZodDefault<z.ZodBoolean>;
+            autoSyncMinutes: z.ZodDefault<z.ZodNumber>;
+            historyMode: z.ZodDefault<z.ZodEnum<{
+                "metadata-only": "metadata-only";
+                "offline-mirror": "offline-mirror";
+            }>>;
+            enabledProviders: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+                chatgpt: "chatgpt";
+                claude: "claude";
+                gemini: "gemini";
+                deepseek: "deepseek";
+                grok: "grok";
+                kimi: "kimi";
+            }>>>;
+            maxReadTurns: z.ZodDefault<z.ZodNumber>;
+            inputRenderMode: z.ZodDefault<z.ZodEnum<{
+                pill: "pill";
+                "raw-text": "raw-text";
+            }>>;
+            picker: z.ZodOptional<z.ZodObject<{
+                commands: z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    order: z.ZodNumber;
+                    limit: z.ZodNumber;
+                }, z.core.$strip>;
+                skills: z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    order: z.ZodNumber;
+                    limit: z.ZodNumber;
+                }, z.core.$strip>;
+                files: z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    order: z.ZodNumber;
+                    limit: z.ZodNumber;
+                }, z.core.$strip>;
+                sessions: z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    order: z.ZodNumber;
+                    limit: z.ZodNumber;
+                }, z.core.$strip>;
+                conversations: z.ZodObject<{
+                    enabled: z.ZodBoolean;
+                    order: z.ZodNumber;
+                    limit: z.ZodNumber;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        initial: {
+            opencliPath: string;
+            profile: string;
+            detailConcurrency: number;
+            autoSync: boolean;
+            syncOnStartup: boolean;
+            autoSyncMinutes: number;
+            historyMode: "metadata-only";
+            enabledProviders: ("chatgpt" | "claude" | "gemini" | "deepseek" | "grok" | "kimi")[];
+            maxReadTurns: number;
+            inputRenderMode: "pill";
+        };
+    };
+    tables: {
+        conversations: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            provider: "chatgpt" | "claude" | "gemini" | "deepseek" | "grok" | "kimi";
+            accountScope: string;
+            externalId: string;
+            title: string;
+            url: string;
+            createdAt: string;
+            updatedAt: string;
+            messageCount: number;
+            partial: boolean;
+            remoteMissing: boolean;
+            syncedAt: string;
+            currentRevision?: string | undefined;
+        }>;
+        revisions: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            conversationKey: string;
+            revision: string;
+            contentHash: string;
+            turnCount: number;
+            activeBranch: string;
+            chunkKeys: string[];
+            partial: boolean;
+            syncedAt: string;
+            expiresAt: string;
+        }>;
+        turn_chunks: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            conversationKey: string;
+            revision: string;
+            index: number;
+            turns: {
+                ordinal: number;
+                messageId: string;
+                parentId: string;
+                branchId: string;
+                role: "user" | "assistant";
+                text: string;
+                createdAt: string;
+                attachments: {
+                    attachmentId: string;
+                    kind: "file" | "image";
+                    name: string;
+                    mimeType: string;
+                    size: number;
+                    status: "available" | "unavailable" | "expired";
+                    locator?: string | undefined;
+                }[];
+            }[];
+        }>;
+        attachments: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            attachmentId: string;
+            kind: "file" | "image";
+            name: string;
+            mimeType: string;
+            size: number;
+            status: "available" | "unavailable" | "expired";
+            conversationKey: string;
+            revision: string;
+            ordinal: number;
+            locator?: string | undefined;
+        }>;
+        sync_states: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            provider: "chatgpt" | "claude" | "gemini" | "deepseek" | "grok" | "kimi";
+            profile: string;
+            accountScope: string;
+            cursor: string;
+            status: "failed" | "cancelled" | "running" | "idle";
+            lastSyncAt: string;
+            lastCompleteScanAt: string;
+            error: string;
+            completed: number;
+            total: number;
+            consecutiveFailures: number;
+            nextEligibleAt: string;
+        }>;
+    };
+};