@xenosystem/agent-interface-host 0.1.3

package/dist/agentSearch/AgentSearchService.js

@@ -0,0 +1,1038 @@
+import { createHash } from 'crypto';
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import { JsonInvertedIndexAdapter } from './JsonInvertedIndexAdapter.js';
+import { createSqliteFtsIndexAdapter } from './SqliteFtsIndexAdapter.js';
+import { indexConversation, indexRuntimeEventEnvelope } from './conversationIndexer.js';
+import { indexWorkspaceMetadata } from './workspaceMetadataIndexer.js';
+import { getWorkspacePolicyService } from '../policy/WorkspacePolicyService.js';
+import { getPluginMcpManagerService } from '../pluginMcp/PluginMcpManagerService.js';
+import { createScopeAcl, estimateTokens, normalizeSearchText, stableDocumentId } from './searchUtils.js';
+const XENO_DIR = join(homedir(), '.xeno');
+const AGENT_CHATS_DIR = join(XENO_DIR, 'agent-chats');
+const RUNTIME_EVENTS_DIR = join(XENO_DIR, 'runtime-events');
+const WORKSPACES_FILE = join(XENO_DIR, 'workspaces.json');
+const SEARCH_DIR = join(XENO_DIR, 'indexes', 'hub-search');
+const SEARCH_MANIFEST = join(SEARCH_DIR, 'manifest.json');
+const SEARCH_SNAPSHOT = join(SEARCH_DIR, 'fallback-inverted.json');
+const SEARCH_SQLITE_DB = join(SEARCH_DIR, 'hub-search.sqlite');
+const ATTACHMENTS_FILE = join(SEARCH_DIR, 'attachments.json');
+const QUERY_PROFILE_FILE = join(SEARCH_DIR, 'query-profile.json');
+const INDEX_LIFECYCLE_FILE = join(SEARCH_DIR, 'index-lifecycle.json');
+const MAX_PROFILE_ENTRIES = 250;
+const MAX_DIRTY_SOURCES = 250;
+const MAX_QUEUED_JOBS = 25;
+const SLOW_QUERY_MS = 750;
+const POLICY_SOURCE_DIRS = [
+    join(XENO_DIR, 'memory'),
+    join(XENO_DIR, 'artifacts'),
+    join(XENO_DIR, 'task-boards'),
+    join(XENO_DIR, 'plugins'),
+    join(XENO_DIR, 'mcp'),
+];
+class IndexJobCancelledError extends Error {
+    constructor(message = 'Search index job was cancelled.') {
+        super(message);
+        this.name = 'IndexJobCancelledError';
+    }
+}
+function ensureSearchDir() {
+    if (!existsSync(SEARCH_DIR))
+        mkdirSync(SEARCH_DIR, { recursive: true });
+}
+function safeReadJson(path, fallback) {
+    try {
+        if (!existsSync(path))
+            return fallback;
+        return JSON.parse(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return fallback;
+    }
+}
+function safeWriteJson(path, value) {
+    ensureSearchDir();
+    writeFileSync(path, JSON.stringify(value, null, 2), 'utf-8');
+}
+function fileFingerprint(path) {
+    try {
+        const stat = statSync(path);
+        return `${path}:${stat.size}:${Math.round(stat.mtimeMs)}`;
+    }
+    catch {
+        return `${path}:missing`;
+    }
+}
+function directoryFingerprint(path) {
+    try {
+        if (!existsSync(path))
+            return `${path}:missing`;
+        const parts = [];
+        const visit = (dir) => {
+            for (const name of readdirSync(dir).sort()) {
+                const child = join(dir, name);
+                const stat = statSync(child);
+                if (stat.isDirectory()) {
+                    visit(child);
+                }
+                else {
+                    parts.push(`${child}:${stat.size}:${Math.round(stat.mtimeMs)}`);
+                }
+            }
+        };
+        visit(path);
+        return createHash('sha256').update(parts.join('\n')).digest('hex');
+    }
+    catch {
+        return `${path}:error`;
+    }
+}
+function computeSourceFingerprint() {
+    const parts = [fileFingerprint(WORKSPACES_FILE)];
+    try {
+        if (existsSync(AGENT_CHATS_DIR)) {
+            const files = readdirSync(AGENT_CHATS_DIR)
+                .filter((file) => file.endsWith('.json'))
+                .sort();
+            for (const file of files)
+                parts.push(fileFingerprint(join(AGENT_CHATS_DIR, file)));
+        }
+    }
+    catch {
+        parts.push('agent-chats:error');
+    }
+    parts.push(directoryFingerprint(RUNTIME_EVENTS_DIR));
+    for (const dir of POLICY_SOURCE_DIRS)
+        parts.push(directoryFingerprint(dir));
+    return createHash('sha256').update(parts.join('\n')).digest('hex');
+}
+function getConversationId(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const id = value.id;
+    return typeof id === 'string' && id.trim() ? id.trim() : undefined;
+}
+function getRuntimeEventConversationId(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const record = value;
+    if (typeof record.conversationId === 'string' && record.conversationId.trim())
+        return record.conversationId.trim();
+    const event = record.event;
+    if (event && typeof event === 'object' && !Array.isArray(event)) {
+        const eventConversationId = event.conversationId;
+        if (typeof eventConversationId === 'string' && eventConversationId.trim())
+            return eventConversationId.trim();
+    }
+    return undefined;
+}
+function readConversationSummary(conversationId) {
+    const safeId = conversationId.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 200);
+    const conversationPath = join(AGENT_CHATS_DIR, `${safeId}.json`);
+    const conversation = safeReadJson(conversationPath, null);
+    if (!conversation) {
+        return { summary: '', tokenEstimate: 0, acl: { visibility: 'global' } };
+    }
+    const title = normalizeSearchText(conversation.title || 'Conversation');
+    const messages = Array.isArray(conversation.messages) ? conversation.messages : [];
+    const selected = messages.slice(-10)
+        .map((message) => {
+        const role = normalizeSearchText(message.role || 'message');
+        const content = normalizeSearchText(message.content || message.error || message.command || '');
+        return content ? `${role}: ${content}` : '';
+    })
+        .filter(Boolean);
+    const summary = [title, ...selected].join('\n').slice(0, 12_000);
+    const scope = {
+        workspaceId: typeof conversation.workspaceId === 'string' ? conversation.workspaceId : undefined,
+        teamId: typeof conversation.teamId === 'string' ? conversation.teamId : undefined,
+        agentId: typeof conversation.agentId === 'string' ? conversation.agentId : undefined,
+        conversationId,
+    };
+    return {
+        summary,
+        tokenEstimate: estimateTokens(summary),
+        acl: createScopeAcl(scope, 'global'),
+    };
+}
+export class AgentSearchService {
+    index = new JsonInvertedIndexAdapter();
+    indexInit = null;
+    building = false;
+    ready = false;
+    error;
+    adapterFallbackReason;
+    sqliteAvailable = false;
+    lastQueryMs;
+    lastFreshCheckMs;
+    lastRebuildMs;
+    sourceFingerprint = null;
+    lastFreshCheckAt = 0;
+    queryProfileCache = null;
+    activeJob = null;
+    queuedJobs = [];
+    lastJob;
+    interruptedJob;
+    dirtySources = [];
+    crashResumeAvailable = false;
+    processingQueue = false;
+    cancelledJobIds = new Set();
+    constructor() {
+        this.restoreLifecycleState();
+    }
+    async query(request) {
+        const t0 = Date.now();
+        try {
+            await this.ensureFresh();
+            const result = this.index.search(request);
+            this.lastQueryMs = Date.now() - t0;
+            this.recordQueryProfile({
+                request,
+                durationMs: this.lastQueryMs,
+                resultCount: result.total,
+                success: true,
+            });
+            return { success: true, ...result, stats: this.buildStats() };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err.message : String(err);
+            this.error = error;
+            this.lastQueryMs = Date.now() - t0;
+            this.recordQueryProfile({
+                request,
+                durationMs: this.lastQueryMs,
+                resultCount: 0,
+                success: false,
+                error,
+            });
+            return { success: false, results: [], total: 0, error, stats: this.buildStats() };
+        }
+    }
+    async hydrate(request) {
+        try {
+            await this.ensureFresh();
+            const document = this.index.getDocument(String(request.id || ''));
+            if (!document)
+                return { success: false, error: 'Search result not found.' };
+            return { success: true, document };
+        }
+        catch (err) {
+            return { success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    async reindex(request = {}) {
+        if (request.cancelActive) {
+            this.cancelIndexing({ reason: request.reason || 'Superseded by a new reindex request.' });
+        }
+        await this.ensureIndexAdapter();
+        const job = this.createIndexJob(request.reason === 'crash-resume' ? 'crash-resume' : 'reindex', {
+            force: !!request.force,
+            reason: request.reason,
+            sourceFingerprint: computeSourceFingerprint(),
+        });
+        return this.enqueueIndexJob(job);
+    }
+    cancelIndexing(request = {}) {
+        const reason = normalizeSearchText(request.reason || 'Cancelled by user.') || 'Cancelled by user.';
+        let cancelledQueued = 0;
+        if (this.activeJob && (!request.jobId || request.jobId === this.activeJob.id)) {
+            this.cancelledJobIds.add(this.activeJob.id);
+            this.activeJob.error = reason;
+            this.activeJob.progress = {
+                ...this.activeJob.progress,
+                phase: 'cancelled',
+                updatedAt: Date.now(),
+            };
+        }
+        const remaining = [];
+        for (const queued of this.queuedJobs) {
+            if (request.jobId && request.jobId !== queued.job.id) {
+                remaining.push(queued);
+                continue;
+            }
+            queued.job.status = 'cancelled';
+            queued.job.error = reason;
+            queued.job.finishedAt = Date.now();
+            queued.job.progress = { ...queued.job.progress, phase: 'cancelled', updatedAt: Date.now() };
+            this.lastJob = queued.job;
+            cancelledQueued += 1;
+            queued.resolve(this.buildStatusSnapshot());
+        }
+        this.queuedJobs = remaining;
+        if (cancelledQueued > 0)
+            this.persistLifecycleState();
+        return this.buildStatusSnapshot();
+    }
+    async status() {
+        await this.ensureFresh(false);
+        return this.buildStatusSnapshot();
+    }
+    async health() {
+        await this.ensureIndexAdapter();
+        return this.buildHealth();
+    }
+    async profile(request = {}) {
+        await this.ensureIndexAdapter();
+        return this.buildQueryProfile(request);
+    }
+    lifecycleStatus() {
+        return this.buildLifecycleStatus();
+    }
+    async repair(request = {}) {
+        const startedAt = Date.now();
+        const repaired = [];
+        try {
+            ensureSearchDir();
+            if (request.cleanSnapshot) {
+                repaired.push(this.tryDeleteFile(SEARCH_MANIFEST, 'search-manifest'));
+                repaired.push(this.tryDeleteFile(SEARCH_SNAPSHOT, 'search-snapshot'));
+            }
+            if (request.cleanupOrphans !== false) {
+                repaired.push(this.cleanupOrphanedSearchArtifacts());
+            }
+            await this.reindex({
+                force: request.force !== false,
+                reason: this.crashResumeAvailable ? 'repair after interrupted search indexing' : 'search repair rebuild',
+                cancelActive: true,
+            });
+            if (request.compact !== false) {
+                repaired.push(this.compactIndex());
+            }
+            const status = await this.status();
+            const corruptCount = status.stats.corruptConversationCount || 0;
+            if (corruptCount > 0) {
+                repaired.push({
+                    id: 'corrupt-conversation-files',
+                    success: true,
+                    detail: `${corruptCount} corrupt conversation file${corruptCount === 1 ? '' : 's'} skipped; index remains available.`,
+                });
+            }
+            repaired.push({
+                id: 'search-index-rebuild',
+                success: !status.error && status.ready,
+                detail: `backend=${status.stats.backend} docs=${status.stats.documentCount}`,
+                error: status.error,
+            });
+            return {
+                success: repaired.every((entry) => entry.success),
+                status,
+                repaired,
+                durationMs: Date.now() - startedAt,
+            };
+        }
+        catch (err) {
+            const status = await this.status().catch(() => ({
+                ready: this.ready,
+                building: this.building,
+                error: err instanceof Error ? err.message : String(err),
+                stats: this.buildStats(),
+                health: this.buildHealth(),
+            }));
+            return {
+                success: false,
+                status,
+                repaired,
+                durationMs: Date.now() - startedAt,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    async attachConversation(request) {
+        const sourceConversationId = normalizeSearchText(request.sourceConversationId);
+        const targetConversationId = normalizeSearchText(request.targetConversationId);
+        if (!sourceConversationId || !targetConversationId) {
+            return { success: false, error: 'Missing source or target conversation ID.' };
+        }
+        if (sourceConversationId === targetConversationId) {
+            return { success: false, error: 'A conversation cannot attach itself.' };
+        }
+        const attachments = this.loadAttachments();
+        const existing = attachments.find((attachment) => (attachment.sourceConversationId === sourceConversationId
+            && attachment.targetConversationId === targetConversationId));
+        if (existing)
+            return { success: true, attachment: existing };
+        const summary = readConversationSummary(sourceConversationId);
+        const attachment = {
+            id: stableDocumentId('attachment', targetConversationId, sourceConversationId, Date.now()),
+            sourceConversationId,
+            targetConversationId,
+            attachedByAgentId: normalizeSearchText(request.attachedByAgentId) || undefined,
+            attachedAt: Date.now(),
+            mode: request.mode || 'summary',
+            selectedMessageIds: request.selectedMessageIds,
+            selectedToolCallIds: request.selectedToolCallIds,
+            summary: summary.summary,
+            tokenEstimate: summary.tokenEstimate,
+            aclSnapshot: summary.acl,
+        };
+        attachments.push(attachment);
+        this.saveAttachments(attachments);
+        return { success: true, attachment };
+    }
+    listAttachments(conversationId) {
+        const id = normalizeSearchText(conversationId);
+        if (!id)
+            return { success: false, attachments: [], error: 'Missing conversation ID.' };
+        return {
+            success: true,
+            attachments: this.loadAttachments().filter((attachment) => attachment.targetConversationId === id),
+        };
+    }
+    detachConversation(attachmentId) {
+        const id = normalizeSearchText(attachmentId);
+        if (!id)
+            return { success: false, error: 'Missing attachment ID.' };
+        const before = this.loadAttachments();
+        const after = before.filter((attachment) => attachment.id !== id);
+        this.saveAttachments(after);
+        return { success: true };
+    }
+    notifySourcesChanged(sourcePath = 'unknown') {
+        this.lastFreshCheckAt = 0;
+        this.markDirtySource(sourcePath, 'dirty');
+    }
+    async ensureFresh(loadSnapshot = true) {
+        const t0 = Date.now();
+        await this.ensureIndexAdapter();
+        if (this.building || this.activeJob) {
+            this.lastFreshCheckMs = Date.now() - t0;
+            return;
+        }
+        const now = Date.now();
+        if (this.ready && now - this.lastFreshCheckAt < 750) {
+            this.lastFreshCheckMs = Date.now() - t0;
+            return;
+        }
+        this.lastFreshCheckAt = now;
+        const fingerprint = computeSourceFingerprint();
+        if (this.crashResumeAvailable) {
+            await this.reindex({ force: true, reason: 'crash-resume' });
+            this.lastFreshCheckMs = Date.now() - t0;
+            return;
+        }
+        if (this.ready && this.sourceFingerprint === fingerprint) {
+            this.lastFreshCheckMs = Date.now() - t0;
+            return;
+        }
+        if (loadSnapshot && this.tryLoadSnapshot(fingerprint)) {
+            this.lastFreshCheckMs = Date.now() - t0;
+            return;
+        }
+        await this.reindex({
+            force: true,
+            reason: this.crashResumeAvailable ? 'crash-resume' : 'source fingerprint changed',
+        });
+        this.lastFreshCheckMs = Date.now() - t0;
+    }
+    async ensureIndexAdapter() {
+        if (this.indexInit)
+            return this.indexInit;
+        this.indexInit = (async () => {
+            try {
+                this.index = await createSqliteFtsIndexAdapter(SEARCH_SQLITE_DB);
+                this.sqliteAvailable = true;
+                this.adapterFallbackReason = undefined;
+            }
+            catch {
+                this.sqliteAvailable = false;
+                this.adapterFallbackReason = 'node:sqlite is unavailable in this runtime; using JSON inverted index fallback.';
+                this.index = new JsonInvertedIndexAdapter();
+            }
+        })();
+        return this.indexInit;
+    }
+    async rebuild(_force, knownFingerprint, job) {
+        if (this.building)
+            return;
+        this.building = true;
+        this.error = undefined;
+        const t0 = Date.now();
+        try {
+            const fingerprint = knownFingerprint || computeSourceFingerprint();
+            const source = await this.loadSourceDocuments(job);
+            if (job && this.cancelledJobIds.has(job.id))
+                throw new IndexJobCancelledError();
+            this.updateJobProgress(job, 'indexing', source.documents.length, source.documents.length, 'search-index');
+            this.index.replaceAll(source.documents, {
+                sourceConversationCount: source.sourceConversationCount,
+                sourceWorkspaceCount: source.sourceWorkspaceCount,
+                corruptConversationCount: source.corruptConversationCount,
+            });
+            if (job && this.cancelledJobIds.has(job.id))
+                throw new IndexJobCancelledError();
+            this.updateJobProgress(job, 'persisting', source.documents.length, source.documents.length, SEARCH_SNAPSHOT);
+            this.sourceFingerprint = fingerprint;
+            this.ready = true;
+            this.saveSnapshot(fingerprint);
+            this.lastRebuildMs = Date.now() - t0;
+        }
+        catch (err) {
+            this.error = err instanceof Error ? err.message : String(err);
+            throw err;
+        }
+        finally {
+            this.building = false;
+        }
+    }
+    buildStats() {
+        const profile = this.buildQueryProfile({ limit: MAX_PROFILE_ENTRIES });
+        return {
+            ...this.index.getStats(),
+            sqliteAvailable: this.sqliteAvailable,
+            fallbackReason: this.adapterFallbackReason,
+            lastQueryMs: this.lastQueryMs,
+            lastFreshCheckMs: this.lastFreshCheckMs,
+            lastRebuildMs: this.lastRebuildMs,
+            slowQueryCount: profile.slowQueries.length,
+            averageQueryMs: profile.averageQueryMs ?? undefined,
+            p95QueryMs: profile.p95QueryMs ?? undefined,
+            failedQueryCount: profile.failedQueryCount,
+        };
+    }
+    buildHealth() {
+        const manifest = safeReadJson(SEARCH_MANIFEST, null);
+        const snapshotPresent = existsSync(SEARCH_SNAPSHOT);
+        const currentFingerprint = computeSourceFingerprint();
+        const manifestFingerprint = manifest?.sourceFingerprint || null;
+        const stale = !!manifestFingerprint && manifestFingerprint !== currentFingerprint;
+        const stats = this.buildStats();
+        const issues = [];
+        if (!this.ready) {
+            issues.push({ id: 'index-not-ready', severity: 'warning', message: 'Search index is not ready yet.' });
+        }
+        if (this.error) {
+            issues.push({ id: 'index-error', severity: 'error', message: 'Search index reported an error.', detail: this.error });
+        }
+        if (!this.sqliteAvailable) {
+            issues.push({
+                id: 'sqlite-unavailable',
+                severity: 'info',
+                message: 'SQLite FTS is unavailable; JSON inverted index fallback is active.',
+                detail: this.adapterFallbackReason,
+            });
+        }
+        if (!manifest) {
+            issues.push({ id: 'manifest-missing', severity: 'warning', message: 'Search manifest is missing and will be recreated on rebuild.' });
+        }
+        if (!snapshotPresent) {
+            issues.push({ id: 'snapshot-missing', severity: 'warning', message: 'Search snapshot is missing and will be recreated on rebuild.' });
+        }
+        if (stale) {
+            issues.push({ id: 'source-changed', severity: 'info', message: 'Search sources changed since the last snapshot.', detail: 'A fresh query or repair will rebuild the index.' });
+        }
+        if (stats.corruptConversationCount > 0) {
+            issues.push({
+                id: 'corrupt-conversations',
+                severity: 'warning',
+                message: `${stats.corruptConversationCount} conversation file${stats.corruptConversationCount === 1 ? '' : 's'} could not be indexed.`,
+            });
+        }
+        if (typeof stats.lastQueryMs === 'number' && stats.lastQueryMs > 1000) {
+            issues.push({ id: 'slow-query', severity: 'warning', message: `Last search query took ${stats.lastQueryMs}ms.` });
+        }
+        if ((stats.slowQueryCount || 0) > 0) {
+            issues.push({ id: 'slow-query-history', severity: 'info', message: `${stats.slowQueryCount} recent slow search quer${stats.slowQueryCount === 1 ? 'y' : 'ies'} recorded.` });
+        }
+        if (typeof stats.p95QueryMs === 'number' && stats.p95QueryMs > SLOW_QUERY_MS) {
+            issues.push({ id: 'query-profile-degraded', severity: 'warning', message: `Search query p95 latency is ${stats.p95QueryMs}ms.` });
+        }
+        if ((stats.failedQueryCount || 0) > 0) {
+            issues.push({ id: 'query-profile-errors', severity: 'info', message: `${stats.failedQueryCount} recent search quer${stats.failedQueryCount === 1 ? 'y' : 'ies'} failed.` });
+        }
+        if (this.crashResumeAvailable) {
+            issues.push({ id: 'index-crash-resume-available', severity: 'warning', message: 'An interrupted search indexing job was detected and can be resumed or repaired.' });
+        }
+        if (this.activeJob) {
+            issues.push({ id: 'index-job-running', severity: 'info', message: `Search index job ${this.activeJob.id} is ${this.activeJob.progress.phase}.` });
+        }
+        const staleDirtySourceCount = this.dirtySources.filter((source) => source.status !== 'indexed').length;
+        if (staleDirtySourceCount > 0) {
+            issues.push({ id: 'dirty-source-queue', severity: 'info', message: `${staleDirtySourceCount} dirty search source${staleDirtySourceCount === 1 ? '' : 's'} queued for indexing.` });
+        }
+        return {
+            checkedAt: Date.now(),
+            healthy: issues.every((issue) => issue.severity !== 'error'),
+            stale: stale || staleDirtySourceCount > 0 || this.crashResumeAvailable,
+            sourceFingerprintKnown: !!this.sourceFingerprint || !!manifestFingerprint,
+            manifestPresent: !!manifest,
+            snapshotPresent,
+            issues,
+        };
+    }
+    tryDeleteFile(path, id) {
+        try {
+            if (!existsSync(path))
+                return { id, success: true, detail: 'Already absent.' };
+            unlinkSync(path);
+            return { id, success: true, detail: 'Deleted stale cache file.' };
+        }
+        catch (err) {
+            return { id, success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    cleanupOrphanedSearchArtifacts() {
+        try {
+            ensureSearchDir();
+            const removable = readdirSync(SEARCH_DIR)
+                .filter((file) => (/\.(tmp|bak|old|corrupt)$/i.test(file)
+                || /^hub-search-orphan-/i.test(file)
+                || /^repair-\d+-/i.test(file)));
+            for (const file of removable) {
+                unlinkSync(join(SEARCH_DIR, file));
+            }
+            return {
+                id: 'search-orphan-artifacts',
+                success: true,
+                detail: removable.length ? `Removed ${removable.length} orphaned search cache artifact${removable.length === 1 ? '' : 's'}.` : 'No orphaned search cache artifacts found.',
+            };
+        }
+        catch (err) {
+            return { id: 'search-orphan-artifacts', success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    compactIndex() {
+        try {
+            const result = this.index.compact?.() || { success: true, detail: 'Index backend does not require compaction.' };
+            return {
+                id: 'search-index-compact',
+                success: result.success,
+                detail: result.detail,
+                error: result.error,
+            };
+        }
+        catch (err) {
+            return { id: 'search-index-compact', success: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
+    createIndexJob(kind, options) {
+        const now = Date.now();
+        return {
+            id: stableDocumentId('search-index-job', kind, now, Math.random().toString(36).slice(2, 8)),
+            kind,
+            status: 'queued',
+            force: options.force,
+            reason: options.reason,
+            sourceFingerprint: options.sourceFingerprint,
+            queuedAt: now,
+            attempt: 1,
+            progress: {
+                phase: 'queued',
+                completed: 0,
+                total: 1,
+                percent: 0,
+                updatedAt: now,
+            },
+        };
+    }
+    enqueueIndexJob(job) {
+        if (this.queuedJobs.length >= MAX_QUEUED_JOBS) {
+            const dropped = this.queuedJobs.shift();
+            if (dropped) {
+                dropped.job.status = 'cancelled';
+                dropped.job.error = 'Dropped because the search index queue was full.';
+                dropped.job.finishedAt = Date.now();
+                dropped.resolve(this.buildStatusSnapshot());
+            }
+        }
+        this.markDirtySourcesQueued();
+        const promise = new Promise((resolve) => {
+            this.queuedJobs.push({ job, resolve });
+        });
+        this.persistLifecycleState();
+        void this.processIndexQueue();
+        return promise;
+    }
+    async processIndexQueue() {
+        if (this.processingQueue)
+            return;
+        this.processingQueue = true;
+        try {
+            while (this.queuedJobs.length > 0) {
+                const item = this.queuedJobs.shift();
+                if (!item)
+                    continue;
+                const job = item.job;
+                this.activeJob = job;
+                this.cancelledJobIds.delete(job.id);
+                job.status = 'running';
+                job.startedAt = Date.now();
+                this.updateJobProgress(job, 'loading-sources', 0, this.estimateSourceUnitCount(), job.sourceFingerprint);
+                this.persistLifecycleState();
+                try {
+                    await this.rebuild(job.force, job.sourceFingerprint, job);
+                    job.status = 'completed';
+                    job.finishedAt = Date.now();
+                    this.updateJobProgress(job, 'completed', job.progress.total, job.progress.total, SEARCH_MANIFEST);
+                    this.crashResumeAvailable = false;
+                    this.interruptedJob = undefined;
+                    this.markQueuedDirtySourcesIndexed(job.finishedAt);
+                }
+                catch (err) {
+                    const cancelled = err instanceof IndexJobCancelledError || this.cancelledJobIds.has(job.id);
+                    job.status = cancelled ? 'cancelled' : 'failed';
+                    job.finishedAt = Date.now();
+                    job.error = err instanceof Error ? err.message : String(err);
+                    if (cancelled)
+                        this.error = undefined;
+                    job.progress = {
+                        ...job.progress,
+                        phase: cancelled ? 'cancelled' : 'failed',
+                        updatedAt: Date.now(),
+                    };
+                    if (!cancelled) {
+                        job.backoffMs = Math.min(5_000, Math.max(250, job.attempt * 500));
+                    }
+                }
+                finally {
+                    this.building = false;
+                    this.cancelledJobIds.delete(job.id);
+                    this.lastJob = job;
+                    this.activeJob = null;
+                    this.persistLifecycleState();
+                    item.resolve(this.buildStatusSnapshot());
+                }
+            }
+        }
+        finally {
+            this.processingQueue = false;
+            this.persistLifecycleState();
+        }
+    }
+    updateJobProgress(job, phase, completed, total, currentSource) {
+        if (!job)
+            return;
+        const safeTotal = Math.max(1, total);
+        const safeCompleted = Math.max(0, Math.min(completed, safeTotal));
+        job.progress = {
+            phase,
+            completed: safeCompleted,
+            total: safeTotal,
+            percent: Math.max(0, Math.min(100, Math.round((safeCompleted / safeTotal) * 100))),
+            currentSource,
+            updatedAt: Date.now(),
+        };
+        this.persistLifecycleState();
+    }
+    buildStatusSnapshot() {
+        return {
+            ready: this.ready,
+            building: this.building || !!this.activeJob,
+            error: this.error,
+            stats: this.buildStats(),
+            health: this.buildHealth(),
+            lifecycle: this.buildLifecycleStatus(),
+        };
+    }
+    buildLifecycleStatus() {
+        const queuedJobs = this.queuedJobs.map((item) => item.job);
+        const dirtySources = this.dirtySources.slice().sort((a, b) => b.lastSeenAt - a.lastSeenAt);
+        return {
+            activeJob: this.activeJob || undefined,
+            queuedJobs,
+            lastJob: this.lastJob,
+            interruptedJob: this.interruptedJob,
+            dirtySources,
+            staleDirtySourceCount: dirtySources.filter((source) => source.status !== 'indexed').length,
+            crashResumeAvailable: this.crashResumeAvailable,
+            cancellable: !!this.activeJob || queuedJobs.length > 0,
+        };
+    }
+    restoreLifecycleState() {
+        const persisted = safeReadJson(INDEX_LIFECYCLE_FILE, null);
+        if (!persisted || persisted.version !== 1)
+            return;
+        this.dirtySources = Array.isArray(persisted.dirtySources) ? persisted.dirtySources.slice(-MAX_DIRTY_SOURCES) : [];
+        this.lastJob = persisted.lastJob;
+        this.interruptedJob = persisted.interruptedJob;
+        this.crashResumeAvailable = persisted.crashResumeAvailable === true;
+        const interrupted = [persisted.activeJob, ...(Array.isArray(persisted.queuedJobs) ? persisted.queuedJobs : [])]
+            .filter((job) => !!job && (job.status === 'running' || job.status === 'queued'))
+            .sort((a, b) => (b.startedAt || b.queuedAt) - (a.startedAt || a.queuedAt))[0];
+        if (interrupted) {
+            const now = Date.now();
+            this.interruptedJob = {
+                ...interrupted,
+                status: 'interrupted',
+                finishedAt: now,
+                error: 'Process exited before the search index job completed.',
+                progress: {
+                    ...interrupted.progress,
+                    phase: 'failed',
+                    updatedAt: now,
+                },
+            };
+            this.lastJob = this.interruptedJob;
+            this.crashResumeAvailable = true;
+            this.markDirtySource('interrupted-index-job', 'dirty');
+        }
+        this.persistLifecycleState();
+    }
+    persistLifecycleState() {
+        try {
+            safeWriteJson(INDEX_LIFECYCLE_FILE, {
+                version: 1,
+                activeJob: this.activeJob || undefined,
+                queuedJobs: this.queuedJobs.map((item) => item.job),
+                lastJob: this.lastJob,
+                interruptedJob: this.interruptedJob,
+                dirtySources: this.dirtySources.slice(-MAX_DIRTY_SOURCES),
+                crashResumeAvailable: this.crashResumeAvailable,
+                savedAt: Date.now(),
+            });
+        }
+        catch {
+            // Lifecycle state improves recovery but search can still rebuild from source.
+        }
+    }
+    markDirtySource(path, status) {
+        const normalizedPath = normalizeSearchText(path).slice(0, 1000) || 'unknown';
+        const now = Date.now();
+        const existing = this.dirtySources.find((source) => source.path === normalizedPath);
+        if (existing) {
+            existing.lastSeenAt = now;
+            existing.eventCount += 1;
+            existing.status = status;
+            if (status !== 'indexed')
+                existing.indexedAt = undefined;
+        }
+        else {
+            this.dirtySources.push({
+                path: normalizedPath,
+                firstSeenAt: now,
+                lastSeenAt: now,
+                eventCount: 1,
+                status,
+            });
+        }
+        this.dirtySources = this.dirtySources
+            .sort((a, b) => b.lastSeenAt - a.lastSeenAt)
+            .slice(0, MAX_DIRTY_SOURCES);
+        this.persistLifecycleState();
+    }
+    markDirtySourcesQueued() {
+        for (const source of this.dirtySources) {
+            if (source.status === 'dirty')
+                source.status = 'queued';
+        }
+    }
+    markQueuedDirtySourcesIndexed(indexedAt = Date.now()) {
+        for (const source of this.dirtySources) {
+            if (source.status === 'queued') {
+                source.status = 'indexed';
+                source.indexedAt = indexedAt;
+            }
+        }
+    }
+    estimateSourceUnitCount() {
+        let count = 1;
+        try {
+            if (existsSync(AGENT_CHATS_DIR)) {
+                count += readdirSync(AGENT_CHATS_DIR).filter((file) => file.endsWith('.json')).length;
+            }
+        }
+        catch {
+            count += 1;
+        }
+        try {
+            if (existsSync(RUNTIME_EVENTS_DIR)) {
+                count += readdirSync(RUNTIME_EVENTS_DIR).filter((file) => file.endsWith('.jsonl')).length;
+            }
+        }
+        catch {
+            count += 1;
+        }
+        return Math.max(1, count);
+    }
+    async yieldToEventLoop() {
+        await new Promise((resolve) => setImmediate(resolve));
+    }
+    async loadSourceDocuments(job) {
+        const documents = [];
+        let sourceConversationCount = 0;
+        let sourceWorkspaceCount = 0;
+        let corruptConversationCount = 0;
+        const conversationsById = new Map();
+        const totalSourceCount = this.estimateSourceUnitCount();
+        let completedSourceCount = 0;
+        const checkpoint = async (currentSource) => {
+            if (job && this.cancelledJobIds.has(job.id))
+                throw new IndexJobCancelledError();
+            completedSourceCount += 1;
+            this.updateJobProgress(job, 'loading-sources', completedSourceCount, totalSourceCount, currentSource);
+            if (completedSourceCount % 25 === 0)
+                await this.yieldToEventLoop();
+        };
+        const workspaces = safeReadJson(WORKSPACES_FILE, []);
+        sourceWorkspaceCount = Array.isArray(workspaces) ? workspaces.length : 0;
+        documents.push(...indexWorkspaceMetadata(workspaces));
+        documents.push(...getWorkspacePolicyService().toSearchDocuments());
+        documents.push(...getPluginMcpManagerService().toSearchDocuments());
+        await checkpoint(WORKSPACES_FILE);
+        try {
+            if (existsSync(AGENT_CHATS_DIR)) {
+                const files = readdirSync(AGENT_CHATS_DIR).filter((file) => file.endsWith('.json')).sort();
+                for (const file of files) {
+                    const path = join(AGENT_CHATS_DIR, file);
+                    try {
+                        const conversation = JSON.parse(readFileSync(path, 'utf-8'));
+                        const conversationId = getConversationId(conversation);
+                        if (conversationId)
+                            conversationsById.set(conversationId, conversation);
+                        const indexed = indexConversation(conversation, path);
+                        if (indexed.length > 0)
+                            sourceConversationCount += 1;
+                        documents.push(...indexed);
+                    }
+                    catch {
+                        corruptConversationCount += 1;
+                    }
+                    await checkpoint(path);
+                }
+            }
+        }
+        catch {
+            // Keep workspace search available even when the conversation directory is temporarily unavailable.
+        }
+        try {
+            if (existsSync(RUNTIME_EVENTS_DIR)) {
+                const files = readdirSync(RUNTIME_EVENTS_DIR).filter((file) => file.endsWith('.jsonl')).sort();
+                for (const file of files) {
+                    const path = join(RUNTIME_EVENTS_DIR, file);
+                    const lines = readFileSync(path, 'utf-8').split(/\r?\n/);
+                    for (const [lineIndex, line] of lines.entries()) {
+                        const trimmed = line.trim();
+                        if (!trimmed)
+                            continue;
+                        try {
+                            const envelope = JSON.parse(trimmed);
+                            const conversationId = getRuntimeEventConversationId(envelope);
+                            documents.push(...indexRuntimeEventEnvelope(envelope, path, conversationId ? conversationsById.get(conversationId) : undefined, lineIndex + 1));
+                        }
+                        catch {
+                            // Runtime JSONL traces are append-only; skip partial/corrupt lines without blocking search.
+                        }
+                    }
+                    await checkpoint(path);
+                }
+            }
+        }
+        catch {
+            // Runtime traces are supplementary search sources and must not block conversation/workspace search.
+        }
+        return { documents, sourceConversationCount, sourceWorkspaceCount, corruptConversationCount };
+    }
+    tryLoadSnapshot(sourceFingerprint) {
+        try {
+            const manifest = safeReadJson(SEARCH_MANIFEST, null);
+            if (!manifest || manifest.sourceFingerprint !== sourceFingerprint)
+                return false;
+            const snapshot = safeReadJson(SEARCH_SNAPSHOT, null);
+            if (!snapshot?.documents?.length)
+                return false;
+            this.index.importSnapshot(snapshot);
+            this.sourceFingerprint = sourceFingerprint;
+            this.ready = true;
+            this.error = undefined;
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    saveSnapshot(sourceFingerprint) {
+        try {
+            const snapshot = this.index.exportSnapshot();
+            safeWriteJson(SEARCH_SNAPSHOT, snapshot);
+            safeWriteJson(SEARCH_MANIFEST, {
+                version: 1,
+                sourceFingerprint,
+                builtAt: Date.now(),
+                stats: snapshot.stats,
+            });
+        }
+        catch {
+            // Search can always rebuild, so snapshot write failures should not break chat.
+        }
+    }
+    loadAttachments() {
+        const value = safeReadJson(ATTACHMENTS_FILE, []);
+        return Array.isArray(value) ? value : [];
+    }
+    saveAttachments(attachments) {
+        safeWriteJson(ATTACHMENTS_FILE, attachments.slice(-5000));
+    }
+    loadQueryProfile() {
+        if (this.queryProfileCache)
+            return this.queryProfileCache;
+        const value = safeReadJson(QUERY_PROFILE_FILE, []);
+        this.queryProfileCache = Array.isArray(value)
+            ? value.filter((entry) => (!!entry
+                && typeof entry.id === 'string'
+                && typeof entry.timestamp === 'number'
+                && typeof entry.durationMs === 'number'
+                && typeof entry.query === 'string')).slice(-MAX_PROFILE_ENTRIES)
+            : [];
+        return this.queryProfileCache;
+    }
+    saveQueryProfile(entries) {
+        const limited = entries.slice(-MAX_PROFILE_ENTRIES);
+        this.queryProfileCache = limited;
+        safeWriteJson(QUERY_PROFILE_FILE, limited);
+    }
+    recordQueryProfile(params) {
+        try {
+            const query = normalizeSearchText(params.request.query).slice(0, 240);
+            const entries = this.loadQueryProfile();
+            entries.push({
+                id: stableDocumentId('search-query-profile', Date.now(), Math.random().toString(36).slice(2, 8)),
+                timestamp: Date.now(),
+                query,
+                mode: params.request.mode,
+                durationMs: Math.max(0, Math.round(params.durationMs)),
+                resultCount: Math.max(0, Math.floor(params.resultCount)),
+                success: params.success,
+                error: params.error ? normalizeSearchText(params.error).slice(0, 500) : undefined,
+                caller: params.request.caller,
+            });
+            this.saveQueryProfile(entries);
+        }
+        catch {
+            // Query profiling must never block search.
+        }
+    }
+    buildQueryProfile(request = {}) {
+        const limit = Math.max(1, Math.min(Number(request.limit) || 50, MAX_PROFILE_ENTRIES));
+        const all = this.loadQueryProfile()
+            .slice()
+            .sort((a, b) => b.timestamp - a.timestamp);
+        const slowQueries = all.filter((entry) => entry.durationMs >= SLOW_QUERY_MS);
+        const selected = (request.slowOnly ? slowQueries : all).slice(0, limit);
+        const durations = all.map((entry) => entry.durationMs).filter((duration) => Number.isFinite(duration)).sort((a, b) => a - b);
+        const failedQueryCount = all.filter((entry) => !entry.success).length;
+        const averageQueryMs = durations.length
+            ? Math.round(durations.reduce((sum, duration) => sum + duration, 0) / durations.length)
+            : null;
+        const p95Index = durations.length ? Math.min(durations.length - 1, Math.ceil(durations.length * 0.95) - 1) : -1;
+        const p95QueryMs = p95Index >= 0 ? durations[p95Index] : null;
+        return {
+            entries: selected,
+            slowQueries: slowQueries.slice(0, limit),
+            averageQueryMs,
+            p95QueryMs,
+            failedQueryCount,
+            health: failedQueryCount > Math.max(3, all.length / 2)
+                ? 'failing'
+                : p95QueryMs !== null && p95QueryMs > SLOW_QUERY_MS
+                    ? 'degraded'
+                    : 'healthy',
+        };
+    }
+}
+let singleton = null;
+export function getAgentSearchService() {
+    if (!singleton)
+        singleton = new AgentSearchService();
+    return singleton;
+}
+//# sourceMappingURL=AgentSearchService.js.map