vault-go 0.20.0 → 0.22.0

package/dist/hooks.js

@@ -1,9 +1,14 @@
+import { redact } from './capture-privacy.js';
+export { redact } from './capture-privacy.js';
 import { createHash, randomUUID } from "node:crypto";
-import { basename, dirname, resolve } from "node:path";
-import { existsSync } from "node:fs";
+import { basename, dirname, isAbsolute, relative, resolve } from "node:path";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { applyCustomModeContext } from './custom-modes.js';
 import { VaultCloudClient } from "./cloud.js";
 import { vaultHome } from "./config.js";
 import { enqueueGeneration } from "./hook-queue.js";
+import { transcriptCaptureEnabled } from './transcript-config.js';
+import { loadProjectContext } from './context-chain.js';
 export const HOOK_EVENTS = [
     "context",
     "session-init",
@@ -16,6 +21,14 @@ const record = (value) => value && typeof value === "object" && !Array.isArray(v
     : {};
 const string = (...values) => values.find((value) => typeof value === "string" && value.trim()) ||
     "";
+function resolvedPath(path) {
+    try {
+        return realpathSync(resolve(path));
+    }
+    catch {
+        return resolve(path);
+    }
+}
 function root(cwd) {
     const initial = resolve(cwd);
     let dir = initial;
@@ -26,24 +39,42 @@ function root(cwd) {
     }
     return initial;
 }
-export function redact(value) {
-    if (typeof value === "string") {
-        return value
-            .replace(/<(private|vault-private|claude-mem-context|system_instruction|system-instruction|persisted-output|system-reminder)\b[^>]*>[\s\S]*?(?:<\/\1\s*>|$)/gi, "[redacted]")
-            .replace(/(api[_-]?key|secret|token|password)\s*[:=]\s*['"]?[^\s'"]+/gi, "$1=[redacted]");
+function gitMetadata(path) {
+    const file = statSync(path);
+    if (!file.isFile() || file.size > 4096)
+        return "";
+    return readFileSync(path, "utf8").trim();
+}
+function projectRoots(workspace) {
+    const fallback = [resolvedPath(workspace)];
+    try {
+        const marker = /^gitdir:\s*(.+)$/.exec(gitMetadata(resolve(workspace, ".git")));
+        if (!marker)
+            return fallback;
+        const gitdir = resolve(workspace, marker[1]);
+        const common = gitMetadata(resolve(gitdir, "commondir"));
+        // A submodule or separate git directory has no shared worktree metadata.
+        if (!common)
+            return fallback;
+        const shared = resolvedPath(resolve(gitdir, common));
+        if (basename(shared) !== ".git" || !statSync(shared).isDirectory())
+            return fallback;
+        return [...new Set([dirname(shared), ...fallback])];
     }
-    if (Array.isArray(value))
-        return value.map(redact);
-    if (value && typeof value === "object") {
-        const output = {};
-        for (const [key, nested] of Object.entries(value)) {
-            output[key] = /api[_-]?key|secret|token|password|authorization|cookie|credential|private[_-]?key/i.test(key)
-                ? "[redacted]"
-                : redact(nested);
+    catch {
+        // Keep existing projects usable if Git metadata is absent or unreadable.
+        return fallback;
+    }
+}
+function canonicalFile(file, workspace, project) {
+    const absolute = resolve(workspace, file);
+    for (const directory of [workspace, resolvedPath(workspace)]) {
+        const path = relative(directory, absolute);
+        if (path !== ".." && !path.startsWith("../") && !path.startsWith("..\\") && !isAbsolute(path)) {
+            return resolve(project, path);
         }
-        return output;
     }
-    return value;
+    return absolute;
 }
 export function normalizeHookInput(adapter, value) {
     const input = record(value);
@@ -58,7 +89,7 @@ export function normalizeHookInput(adapter, value) {
         cwd: string(input.cwd, input.workspace, input.workspaceRoot, workspace),
         tool_name: string(input.tool_name, input.toolName, toolCall.name),
         tool_input: record(input.tool_input ?? input.toolInput ?? toolCall.args),
-        last_assistant_message: string(input.last_assistant_message, input.lastAssistantMessage, input.response, input.summary),
+        last_assistant_message: string(input.last_assistant_message, input.lastAssistantMessage, input.prompt_response, input.response, input.summary),
         prompt: string(input.prompt, input.user_prompt, input.userPrompt),
     };
 }
@@ -73,19 +104,24 @@ export function hookOutput(event, context = "", adapter = "claude") {
             return { decision: "allow" };
         return {};
     }
-    const result = { continue: true, suppressOutput: true };
+    const result = adapter === "codex"
+        ? {}
+        : { continue: true, suppressOutput: true };
     const name = event === "context"
         ? "SessionStart"
         : event === "file-context"
             ? "PreToolUse"
             : event === "session-init"
-                ? "UserPromptSubmit"
+                ? adapter === "gemini" ? "BeforeAgent" : "UserPromptSubmit"
                 : "";
     if (name && context) {
         result.hookSpecificOutput = {
             hookEventName: name,
             additionalContext: context,
         };
+        if (event === "context" && ["claude", "codex", "gemini"].includes(adapter)) {
+            result.systemMessage = "Vault Memory: contexto do projeto carregado.";
+        }
     }
     return result;
 }
@@ -105,8 +141,10 @@ async function preferences(cloud) {
         contextMaxChars: 24_000,
     };
 }
-export async function executeHook(adapter, event, value, cloud = new VaultCloudClient(), home = vaultHome()) {
+export async function executeHook(adapter, event, value, cloud = new VaultCloudClient(), home = vaultHome(), options = {}) {
     const input = normalizeHookInput(adapter, value);
+    if (event !== 'context' && event !== 'file-context' && !options.transcript && transcriptCaptureEnabled(home, adapter, string(input.cwd, input.workspace) || process.cwd()))
+        return hookOutput(event, '', adapter);
     const toolName = string(input.tool_name);
     if (input.private === true ||
         input.is_private === true ||
@@ -130,15 +168,17 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     const sessionId = string(input.session_id);
     if (!reading && !sessionId)
         return hookOutput(event, "", adapter);
-    const cwd = root(string(input.cwd, input.workspace) || process.cwd());
+    const workspace = root(string(input.cwd, input.workspace) || process.cwd());
+    const roots = projectRoots(workspace);
     const projects = await cloud.projects();
     if (!Array.isArray(projects))
         throw new Error("Resposta de projetos inválida");
-    let project = projects.find((item) => item &&
+    let project = roots.map((cwd) => projects.find((item) => item &&
         typeof item === "object" &&
         typeof item.rootPath === "string" &&
         Boolean(String(item.rootPath).trim()) &&
-        resolve(String(item.rootPath)) === cwd);
+        resolvedPath(String(item.rootPath)) === cwd)).find(Boolean);
+    const cwd = project ? resolvedPath(String(project.rootPath)) : roots[0];
     if (!project && reading)
         return hookOutput(event, "", adapter);
     if (!project) {
@@ -154,14 +194,23 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
         limit: boundedPreference(prefs.contextItems, 20, 1, 100),
         maxChars: boundedPreference(prefs.contextMaxChars, 24_000, 1_000, 100_000),
     };
+    const projectFile = file ? canonicalFile(file, workspace, cwd) : "";
+    const files = file
+        ? [...new Set([file, ...(resolvedPath(workspace) !== cwd ? [projectFile] : [])])]
+        : [];
     if (reading) {
         const result = record(event === "file-context"
             ? await cloud.fileContext({
                 ...limits,
-                paths: [...new Set([file, resolve(cwd, file)])],
+                paths: [...new Set([file, resolve(workspace, file), projectFile])],
             })
-            : await cloud.context(limits));
-        return hookOutput(event, string(result.context).slice(0, limits.maxChars), adapter);
+            : { context: await loadProjectContext(home, cloud, { workspace, primary: { id: project.id }, projects, ...limits }) });
+        let context = string(result.context).slice(0, limits.maxChars);
+        try {
+            context = applyCustomModeContext(home, context, limits.maxChars);
+        }
+        catch { /* invalid local mode never blocks cloud context */ }
+        return hookOutput(event, context, adapter);
     }
     const session = record(await cloud.startSession({
         projectId: project.id,
@@ -204,6 +253,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
             content,
         ]))
             .digest("hex");
+        const timestamp = options.transcript && typeof input.timestamp === 'string' ? Date.parse(input.timestamp) : NaN;
         await cloud.event({
             projectId: project.id,
             sessionId: session.id,
@@ -218,23 +268,24 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
                 title: toolName ||
                     (event === "summarize" ? "Resumo da sessão" : "Solicitação do usuário"),
                 content,
-                filesRead: !modifies && file ? [file] : [],
-                filesModified: modifies && file ? [file] : [],
+                filesRead: !modifies ? files : [],
+                filesModified: modifies ? files : [],
             },
-            occurredAtEpoch: Date.now(),
+            occurredAtEpoch: Number.isFinite(timestamp) && timestamp >= 0 && timestamp <= Date.now() + 300_000 ? timestamp : Date.now(),
         });
         await enqueueGeneration(home, {
             id: sourceEventId,
             generate: prefs.summaryMode !== 'off',
             projectId: project.id,
             sessionId: session.id,
+            ...(string(input.agent_id, input.agentId) ? { agentId: string(input.agent_id, input.agentId) } : {}),
             text: content.slice(0, 16_000),
             title: toolName ||
                 (event === "summarize" ? "Resumo da sessão" : "Solicitação do usuário"),
             kind: event === "summarize" ? "summary" : event === "session-init" ? "prompt" : "observation",
             maxChars: boundedPreference(prefs.summaryMaxChars, 4_000, 256, 16_000),
-            filesRead: !modifies && file ? [file] : [],
-            filesModified: modifies && file ? [file] : [],
+            filesRead: !modifies ? files : [],
+            filesModified: modifies ? files : [],
         });
     }
     if (event === "summarize")

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env bun
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { cliArguments, helpText, resolveCliMode, runEngine, runLocal, runLogin, runSetup, runUpdate } from './cli.js';
+import { cliArguments, helpText, resolveCliMode, runEngine, runLocal, runLogin, runSetup, runUpdate, runTranscripts, runContextChain } from './cli.js';
 import { HOOK_EVENTS, runHook } from './hooks.js';
 import { createVaultGoServer, VERSION } from './server.js';
 const { argument, options } = cliArguments(process.argv.slice(2));
@@ -37,6 +37,14 @@ async function main() {
         process.exitCode = await runUpdate(options);
         return;
     }
+    if (mode === 'transcripts') {
+        process.exitCode = await runTranscripts(options);
+        return;
+    }
+    if (mode === 'context-chain') {
+        process.exitCode = await runContextChain(options);
+        return;
+    }
     if (mode === 'hook') {
         const adapter = options.find((item) => !item.startsWith('--')) ?? 'auto';
         const event = options.filter((item) => !item.startsWith('--'))[1];

package/dist/installer.js

@@ -4,7 +4,7 @@ import { dirname, join, resolve } from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { vaultHome } from './config.js';
 import { stageLocalRuntime } from './local-install.js';
-import { installClientHooks } from './hook-install.js';
+import { installClientHooks, installOpenCodePlugin } from './hook-install.js';
 export const MCP_SERVER_NAME = 'vault-go';
 export const MCP_SERVER_COMMAND = ['bunx', '--bun', 'vault-go@latest', 'serve'];
 export const MCP_CLIENTS = [
@@ -199,6 +199,11 @@ export function installMcpClient(client, options = {}) {
     if (client === 'gemini') {
         const path = join(home, '.gemini', 'settings.json');
         mergeServer(path);
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* incomplete installs still write hooks */ }
+        installClientHooks('gemini', home);
         return { client, status: 'installed', destination: path };
     }
     if (client === 'vault-desktop') {
@@ -221,6 +226,11 @@ export function installMcpClient(client, options = {}) {
     else
         path = join(home, '.config', 'opencode', 'opencode.json');
     if (client === 'opencode') {
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* plugin becomes active when runtime is available */ }
+        installOpenCodePlugin(home);
         mergeServer(path, 'mcp', {
             type: 'local',
             command: [...MCP_SERVER_COMMAND],

package/dist/knowledge-agent.d.ts

@@ -0,0 +1,39 @@
+import type { VaultMemoryApi } from './cloud.js';
+import { generateContext } from './context-engines.js';
+type Dependencies = {
+    storageKey?: Buffer;
+    generate?: typeof generateContext;
+};
+export declare function primeKnowledgeAgent(home: string, cloud: VaultMemoryApi, id: string, rebuild?: boolean, dependencies?: Dependencies): Promise<{
+    corpusId: string;
+    name: string;
+    primed: boolean;
+    memoryCount: number;
+    conversationReset: boolean;
+    engine: "vault-ai-resume" | "claude-subscription" | "openai-subscription" | "openrouter" | "gemini";
+    model: string;
+}>;
+export declare function queryKnowledgeAgent(home: string, cloud: VaultMemoryApi, id: string, question: string, dependencies?: Dependencies): Promise<{
+    corpusId: string;
+    answer: string;
+    citations: never[];
+    generated: boolean;
+    conversationTurns: number;
+    engine?: never;
+    model?: never;
+    contextTruncated?: never;
+} | {
+    corpusId: string;
+    answer: string;
+    citations: {
+        index: number;
+        memoryId: string;
+        title: string;
+    }[];
+    generated: boolean;
+    engine: "vault-ai-resume" | "claude-subscription" | "openai-subscription" | "openrouter" | "gemini";
+    model: string;
+    conversationTurns: number;
+    contextTruncated: boolean;
+}>;
+export {};

package/dist/knowledge-agent.js

@@ -0,0 +1,143 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { loadConfig, loadTokens } from './config.js';
+import { generateContext, selectedContextEngine, selectedEngineModel } from './context-engines.js';
+import { redact } from './hooks.js';
+import { privateStore } from './private-store.js';
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function accountKey(home) {
+    const config = loadConfig(home), token = process.env.VAULT_GO_TOKEN || loadTokens(home)?.accessToken;
+    if (!token)
+        throw new Error('Conecte sua conta Vault antes de abrir uma conversa.');
+    return createHash('sha256').update(JSON.stringify([config.apiUrl, process.env.VAULT_GO_TOKEN || config.email || token])).digest('hex');
+}
+async function withConversation(home, id, dependencies, action) {
+    if (!uuid.test(id))
+        throw new Error('Identificador de corpus inválido.');
+    const owner = accountKey(home), name = `corpus-${createHash('sha256').update(owner + ':' + id).digest('hex').slice(0, 48)}.json`, path = join(home, `${name}.lock`), lease = randomUUID();
+    mkdirSync(home, { recursive: true, mode: 0o700 });
+    for (let attempt = 0;; attempt++) {
+        try {
+            writeFileSync(path, JSON.stringify({ pid: process.pid, lease }), { mode: 0o600, flag: 'wx' });
+            break;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            let dead = false, staleLease;
+            try {
+                const saved = JSON.parse(readFileSync(path, 'utf8'));
+                staleLease = saved.lease;
+                if (Number.isSafeInteger(saved.pid) && saved.pid > 0) {
+                    try {
+                        process.kill(saved.pid, 0);
+                    }
+                    catch (error) {
+                        dead = error.code === 'ESRCH';
+                    }
+                }
+            }
+            catch { /* An invalid lock is not proof that its owner exited. */ }
+            if (attempt === 0 && dead && staleLease && JSON.parse(readFileSync(path, 'utf8')).lease === staleLease) {
+                rmSync(path, { force: true });
+                continue;
+            }
+            throw new Error('Uma consulta já está em andamento neste corpus. Tente novamente após ela terminar.');
+        }
+    }
+    let store;
+    try {
+        store = privateStore(home, dependencies.storageKey);
+        return await action(store, name, () => { if (owner !== accountKey(home))
+            throw new Error('A conta mudou durante a consulta; resultado descartado.'); });
+    }
+    finally {
+        store?.close();
+        try {
+            if (JSON.parse(readFileSync(path, 'utf8')).lease === lease)
+                rmSync(path, { force: true });
+        }
+        catch { /* Already released. */ }
+    }
+}
+function corpus(value, id) {
+    const record = value;
+    if (record?.base?.id !== id || !Array.isArray(record.memories) || record.memories.some(m => !uuid.test(m.id) || typeof m.content !== 'string'))
+        throw new Error('Resposta inválida da base de conhecimento.');
+    return { name: typeof record.base.name === 'string' ? record.base.name : 'Corpus', memories: record.memories };
+}
+export async function primeKnowledgeAgent(home, cloud, id, rebuild = false, dependencies = {}) {
+    return withConversation(home, id, dependencies, async (store, name, assertAccount) => {
+        if (rebuild)
+            await cloud.rebuildKnowledgeBase(id);
+        const base = corpus(await cloud.knowledgeBase(id), id);
+        assertAccount();
+        const state = { version: 1, corpusId: id, name: base.name, primedAt: Date.now(), turns: [] };
+        store.write(name, state);
+        return { corpusId: id, name: base.name, primed: true, memoryCount: base.memories.length, conversationReset: true, engine: selectedContextEngine(home), model: selectedEngineModel(home, selectedContextEngine(home)) };
+    });
+}
+export async function queryKnowledgeAgent(home, cloud, id, question, dependencies = {}) {
+    const cleanQuestion = String(redact(question)).trim();
+    if (!cleanQuestion || cleanQuestion.length > 1000)
+        throw new Error('A pergunta deve conter entre 1 e 1000 caracteres.');
+    return withConversation(home, id, dependencies, async (store, name, assertAccount) => {
+        const base = corpus(await cloud.knowledgeBase(id), id);
+        assertAccount();
+        const owned = new Map(base.memories.map(memory => [memory.id, memory]));
+        const saved = store.read(name);
+        if (!saved && existsSync(join(home, name)))
+            throw new Error('O histórico cifrado não pôde ser aberto. Reprepare o corpus para reiniciar a conversa.');
+        const state = saved ?? { version: 1, corpusId: id, name: base.name, primedAt: Date.now(), turns: [] };
+        if (state.version !== 1 || state.corpusId !== id || !Array.isArray(state.turns))
+            throw new Error('Histórico inválido. Reprepare o corpus.');
+        const history = state.turns.filter(turn => turn.sourceIds.every(sourceId => owned.has(sourceId))).slice(-4);
+        const retrievalQuestion = [cleanQuestion, history.at(-1)?.question].filter(Boolean).join(' ').slice(0, 1000);
+        const retrieval = await cloud.queryKnowledgeBase(id, { question: retrievalQuestion, limit: 12, summaryMode: 'off' });
+        if (!Array.isArray(retrieval?.citations))
+            throw new Error('Resposta de recuperação inválida.');
+        assertAccount();
+        const ranked = [...new Set([...retrieval.citations.map(c => c.memoryId), ...base.memories.map(m => m.id)])];
+        const sources = [];
+        let budget = 11000;
+        for (const memoryId of ranked) {
+            const memory = owned.get(memoryId);
+            if (!memory || budget < 300 || sources.length >= 12)
+                continue;
+            const content = String(redact(memory.content)).slice(0, Math.min(3500, budget));
+            const title = String(redact(memory.title ?? 'Memória')).slice(0, 200);
+            sources.push({ index: sources.length + 1, memoryId, title, content });
+            budget -= content.length + title.length + 100;
+        }
+        if (sources.length === 0)
+            return { corpusId: id, answer: 'Esta base não contém memórias suficientes para responder.', citations: [], generated: false, conversationTurns: state.turns.length };
+        const conversation = history.map(turn => ({ question: turn.question.slice(0, 350), answer: turn.answer.slice(0, 500) }));
+        let text = JSON.stringify({ sources, conversation });
+        while (text.length > 16000) {
+            if (conversation.length)
+                conversation.shift();
+            else if (sources.length > 1)
+                sources.pop();
+            else
+                sources[0].content = sources[0].content.slice(0, Math.floor(sources[0].content.length / 2));
+            text = JSON.stringify({ sources, conversation });
+        }
+        const engine = selectedContextEngine(home);
+        const options = {
+            purpose: 'knowledge-answer', question: cleanQuestion,
+            ...(cloud.observerGenerate ? { managedGenerate: (source, options) => cloud.observerGenerate(source, options.signal, { purpose: 'knowledge-answer', question: cleanQuestion }) } : {}),
+        };
+        const result = await (dependencies.generate ?? generateContext)(home, engine, text, options);
+        assertAccount();
+        const answer = String(redact(result.content));
+        const cited = [...answer.matchAll(/\[(\d+)\]/g)].map(match => Number(match[1]));
+        if (!cited.length || cited.some(index => index < 1 || index > sources.length))
+            throw new Error('O modelo retornou uma resposta sem citações válidas. A conversa foi preservada.');
+        const citations = [...new Set(cited)].map(index => { const source = sources[index - 1]; return { index, memoryId: source.memoryId, title: source.title }; });
+        state.turns = [...state.turns.slice(-11), { question: cleanQuestion, answer, sourceIds: citations.map(c => c.memoryId) }];
+        state.name = base.name;
+        store.write(name, state);
+        return { corpusId: id, answer, citations, generated: true, engine, model: selectedEngineModel(home, engine), conversationTurns: state.turns.length, contextTruncated: sources.length < base.memories.length || sources.some(source => source.content.length < (owned.get(source.memoryId)?.content.length ?? 0)) };
+    });
+}

package/dist/knowledge-tools.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { VaultMemoryApi } from './cloud.js';
+export declare function registerKnowledgeAgentTools(server: McpServer, home: string, cloud: VaultMemoryApi): void;

package/dist/knowledge-tools.js

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+import { run } from './mcp-result.js';
+import { primeKnowledgeAgent, queryKnowledgeAgent } from './knowledge-agent.js';
+export function registerKnowledgeAgentTools(server, home, cloud) {
+    const id = z.string().uuid();
+    const annotations = { readOnlyHint: false, destructiveHint: false, openWorldHint: true };
+    server.registerTool('vault_go_prime_corpus', {
+        description: 'Prepara uma conversa persistente e cifrada com uma base de conhecimento. Reinicia o histórico desta base; consultas usam o motor/modelo selecionado.',
+        inputSchema: { id }, annotations,
+    }, async ({ id }) => run(() => primeKnowledgeAgent(home, cloud, id)));
+    server.registerTool('vault_go_query_corpus', {
+        description: 'Responde perguntas com o modelo selecionado e citações das memórias. Mantém contexto de até 12 turnos, cifrado localmente e isolado por conta e corpus. Usa a assinatura/créditos do motor escolhido.',
+        inputSchema: { id, question: z.string().trim().min(1).max(1000) }, annotations,
+    }, async ({ id, question }) => run(() => queryKnowledgeAgent(home, cloud, id, question)));
+    server.registerTool('vault_go_reprime_corpus', {
+        description: 'Reaplica os filtros da base e reinicia a conversa usando as memórias atuais. Preserva as memórias de origem.',
+        inputSchema: { id }, annotations,
+    }, async ({ id }) => run(() => primeKnowledgeAgent(home, cloud, id, true)));
+}

package/dist/local-service.js

@@ -13,6 +13,8 @@ import { callbackPage } from "./callback-page.js";
 import { privateStore } from "./private-store.js";
 import { localDevice } from "./local-device.js";
 import { processGenerationQueue } from "./hook-queue.js";
+import { startTranscriptWatchers } from './transcript-watchers.js';
+import { transcriptStatus } from './transcript-config.js';
 import { generateContext, isApiEngine, isContextEngine, listContextEngines, parseEngineModel, saveEngineKey, selectContextEngine, selectEngineModel, selectedContextEngine, } from "./context-engines.js";
 export const LOCAL_PORT = 38850;
 const safeEqual = (a, b) => a.length === b.length &&
@@ -585,6 +587,7 @@ export async function startLocalService(options = {}) {
                     email: config.email,
                     cloud: { connected, error: cloudError, syncing: Boolean(syncing) },
                     device: monitor?.status() ?? { status: "unregistered" },
+                    transcripts: transcriptStatus(home),
                     security: {
                         cache: {
                             encrypted: Boolean(storage),
@@ -644,6 +647,7 @@ export async function startLocalService(options = {}) {
     if (address && typeof address !== "string")
         port = address.port;
     const timer = setInterval(() => void refresh(), options.pollMs ?? 15_000);
+    const transcripts = startTranscriptWatchers(home, accountCloud);
     timer.unref();
     void refresh();
     async function close() {
@@ -652,10 +656,11 @@ export async function startLocalService(options = {}) {
         monitor?.close();
         clearJobs();
         clearInterval(timer);
+        await transcripts.close();
         sessions.clear();
         server.closeAllConnections();
         await new Promise((resolve) => server.close(() => resolve()));
         storage?.close();
     }
-    return { server, port, close, isIdle: () => !generating && !syncing && login?.status !== "pending" && [...jobs.values()].every(job => job.status !== "running") };
+    return { server, port, close, isIdle: () => transcripts.isIdle() && !generating && !syncing && login?.status !== "pending" && [...jobs.values()].every(job => job.status !== "running") };
 }

package/dist/mode-integrations.d.ts

@@ -0,0 +1,9 @@
+import type { Buffer } from 'node:buffer';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { VaultMemoryApi } from './cloud.js';
+export interface ModeIntegrationOptions {
+    storageKey?: Buffer;
+    telegramToken?: string;
+    telegramFetch?: typeof fetch;
+}
+export declare function registerModeIntegrations(server: McpServer, home: string, cloud: VaultMemoryApi, options?: ModeIntegrationOptions): void;