vault-go 0.29.2 → 0.31.0

package/dist/hook-install.js

@@ -35,11 +35,13 @@ function atomicWriteText(path, text) {
 }
 export const HOOK_OWNER = "Vault Go: captura e contexto";
 export const HOOK_EVENTS = {
+    Setup: "setup",
     SessionStart: "context",
     UserPromptSubmit: "session-init",
     PreToolUse: "file-context",
     PostToolUse: "observation",
     Stop: "summarize",
+    SessionEnd: "session-end",
 };
 const GEMINI_EVENTS = {
     SessionStart: "context",
@@ -77,7 +79,7 @@ function hookManifest(adapter, configHome = vaultHome()) {
                                 timeout: event === "context" ? 60 : 20,
                                 statusMessage: HOOK_OWNER,
                             }),
-                            ...(adapter !== "gemini" && (event === "observation" || event === "summarize")
+                            ...(adapter !== "gemini" && (event === "observation" || event === "summarize" || event === "session-end")
                                 ? { async: true }
                                 : {}),
                         },
@@ -102,8 +104,37 @@ function agyHookManifest(configHome = vaultHome()) {
             { matcher: "*", hooks: [agyHandler("observation", configHome)] },
         ],
         Stop: [agyHandler("summarize", configHome)],
+        SessionEnd: [agyHandler("session-end", configHome)],
     };
 }
+const CAPTURE_HOMES = {
+    cursor: ".cursor/hooks.json",
+    windsurf: ".codeium/windsurf/hooks.json",
+    openclaw: ".openclaw/hooks.json",
+    hermes: ".hermes/hooks.json",
+};
+export function installCaptureHooks(adapter, userHome = homedir(), configHome = vaultHome()) {
+    const relative = CAPTURE_HOMES[adapter];
+    if (!relative)
+        throw new Error("Adaptador de captura desconhecido.");
+    const path = join(userHome, relative);
+    const config = existsSync(path) ? readJsonObject(path) : {};
+    const hooks = {
+        ...(config.hooks && typeof config.hooks === "object" && !Array.isArray(config.hooks) ? config.hooks : {}),
+    };
+    const desired = hookManifest(adapter, configHome).hooks;
+    for (const event of Object.keys(desired)) {
+        const current = hooks[event];
+        const retained = Array.isArray(current)
+            ? current.filter((group) => {
+                const text = JSON.stringify(group);
+                return !text.includes(HOOK_OWNER);
+            })
+            : [];
+        hooks[event] = [...retained, ...(desired[event] || [])];
+    }
+    atomicWriteJson(path, { ...config, hooks });
+}
 export function installClientHooks(client, userHome = homedir(), configHome = vaultHome()) {
     if (client === "grok") {
         atomicWriteJson(join(userHome, ".grok", "hooks", "vault-go.json"), hookManifest("grok", configHome));
@@ -173,6 +204,15 @@ export function repairAdditionalClientHooks(userHome = homedir(), configHome = v
         if (server && server.enabled !== false)
             installOpenCodePlugin(userHome, configHome);
     }, report);
+    for (const adapter of Object.keys(CAPTURE_HOMES)) {
+        const relative = CAPTURE_HOMES[adapter];
+        if (!relative)
+            continue;
+        const directory = join(userHome, relative.split("/").slice(0, -1).join("/"));
+        if (existsSync(directory)) {
+            repairClient(adapter, () => installCaptureHooks(adapter, userHome, configHome), report);
+        }
+    }
 }
 function reportRepairWarning(message) {
     process.stderr.write(message + "\n");

package/dist/hook-queue.d.ts

@@ -1,6 +1,8 @@
 import { VaultCloudClient } from './cloud.js';
 import { generateContext, type ContextResult } from './context-engines.js';
 import { type TelegramObservation } from './telegram.js';
+import { privateStore } from './private-store.js';
+import { type CrystalMirrorRecord } from './crystal-memory-mirror.js';
 export interface GenerationJob {
     id: string;
     projectId: string;
@@ -19,6 +21,21 @@ export interface GenerationJob {
     lastError?: string;
     result?: Pick<ContextResult, 'title' | 'content' | 'facts' | 'concepts' | 'type'>;
 }
+export declare function ownerKey(home: string): string;
+export interface PendingCrystalMirror extends CrystalMirrorRecord {
+    owner: string;
+    queuedAt: number;
+}
+export type CrystalMirrorStore = Pick<ReturnType<typeof privateStore>, 'keyStorage' | 'read' | 'write' | 'remove' | 'close'>;
+export type CrystalMirrorStoreFactory = (home: string) => CrystalMirrorStore;
+export declare const MAX_PENDING_CRYSTAL_MIRRORS = 500;
+export declare function pendingCrystalMirrors(home?: string, openStore?: CrystalMirrorStoreFactory): Promise<PendingCrystalMirror[]>;
+export declare function queuePendingCrystalMirror(home: string, owner: string, record: CrystalMirrorRecord, openStore?: CrystalMirrorStoreFactory): Promise<void>;
+/** Retries locked Crystal copies for this account, stopping at the first sign the Crystal is still locked or closed. */
+export declare function flushPendingCrystalMirrors(home?: string, owner?: string, options?: {
+    limit?: number;
+    openStore?: CrystalMirrorStoreFactory;
+}): Promise<number>;
 export declare function enqueueGeneration(home: string, job: GenerationJob): Promise<void>;
 export declare function generationQueueStatus(home?: string): {
     pending: number;
@@ -28,4 +45,5 @@ export declare function generationQueueStatus(home?: string): {
 };
 export declare function processGenerationQueue(home?: string, cloud?: VaultCloudClient, generate?: typeof generateContext, options?: {
     notifyObservation?: (observation: TelegramObservation) => Promise<unknown>;
+    crystalMirrorStore?: CrystalMirrorStoreFactory;
 }): Promise<boolean>;

package/dist/hook-queue.js

@@ -6,9 +6,10 @@ import { loadConfig, loadTokens, vaultHome } from './config.js';
 import { generateContext, selectedContextEngine } from './context-engines.js';
 import { notifyTelegramObservation } from './telegram.js';
 import { pushAwareness } from './grok-awareness.js';
-import { mirrorCrystalMemory } from './crystal-memory-mirror.js';
+import { privateStore } from './private-store.js';
+import { mirrorCrystalMemory, writeCrystalMirror } from './crystal-memory-mirror.js';
 const queuePath = (home) => join(home, 'generation-queue.json');
-function ownerKey(home) {
+export function ownerKey(home) {
     const config = loadConfig(home);
     return createHash('sha256').update(JSON.stringify([config.apiUrl, process.env['VAULT_GO_TOKEN'] || config.email || loadTokens(home)?.accessToken || 'anonymous'])).digest('hex');
 }
@@ -115,6 +116,113 @@ function appliedObservationType(result, sourceId, fallback) {
         ? observationType
         : fallback;
 }
+export const MAX_PENDING_CRYSTAL_MIRRORS = 500;
+const PENDING_MIRROR_STORE = 'crystal-pending-mirrors.json';
+const MAX_PENDING_MIRROR_BYTES = 4 * 1024 * 1024 - 64 * 1024; // private-store refuses records above 4 MiB
+// Why: the user chose to encrypt the Crystal, so its copies never touch disk in
+// plaintext. Without a durable key they live only for this process lifetime.
+const memoryMirrors = new Map();
+function openMirrorStore(home, factory) {
+    try {
+        const store = factory(home);
+        if (store.keyStorage !== 'ephemeral')
+            return store;
+        store.close();
+    }
+    catch { /* OS key store locked or unavailable */ }
+    return null;
+}
+function readStoredMirrors(home, store) {
+    if (!existsSync(join(home, PENDING_MIRROR_STORE)))
+        return [];
+    const value = store.read(PENDING_MIRROR_STORE);
+    if (value?.v === 1 && Array.isArray(value.items))
+        return value.items;
+    // Local key changed or the file was altered: the copies cannot be recovered.
+    store.remove(PENDING_MIRROR_STORE);
+    console.error('vault-go: cópias pendentes para o Crystal ilegíveis (chave local mudou) foram descartadas.');
+    return [];
+}
+function boundPendingMirrors(items) {
+    let next = items.slice(-MAX_PENDING_CRYSTAL_MIRRORS);
+    while (next.length && Buffer.byteLength(JSON.stringify({ v: 1, items: next })) > MAX_PENDING_MIRROR_BYTES)
+        next = next.slice(1);
+    const dropped = items.length - next.length;
+    if (dropped > 0)
+        console.error(`vault-go: ${dropped} cópia(s) pendente(s) mais antiga(s) para o Crystal descartada(s) pelo limite local.`);
+    return next;
+}
+async function mutatePendingMirrors(home, factory, change) {
+    const release = await lock(home, 'crystal-mirror-storage');
+    try {
+        const store = openMirrorStore(home, factory);
+        const memory = memoryMirrors.get(home) ?? [];
+        if (!store) {
+            memoryMirrors.set(home, boundPendingMirrors(change(memory)));
+            return 'memory';
+        }
+        try {
+            // Copies held in memory while the key was unavailable move into the encrypted file.
+            const stored = readStoredMirrors(home, store);
+            const merged = [...stored.filter(item => !memory.some(held => held.sourceId === item.sourceId)), ...memory];
+            const next = boundPendingMirrors(change(merged));
+            if (next.length)
+                store.write(PENDING_MIRROR_STORE, { v: 1, items: next });
+            else
+                store.remove(PENDING_MIRROR_STORE);
+            memoryMirrors.delete(home);
+            return 'encrypted';
+        }
+        finally {
+            store.close();
+        }
+    }
+    finally {
+        release?.();
+    }
+}
+export async function pendingCrystalMirrors(home = vaultHome(), openStore = privateStore) {
+    let items = [];
+    await mutatePendingMirrors(home, openStore, current => (items = current));
+    return items;
+}
+export async function queuePendingCrystalMirror(home, owner, record, openStore = privateStore) {
+    let held = 0;
+    const storage = await mutatePendingMirrors(home, openStore, items => {
+        // Same sourceId replaces the older copy; Desktop also dedups writes by sourceId.
+        const next = [...items.filter(item => item.sourceId !== record.sourceId), { ...record, owner, queuedAt: Date.now() }];
+        held = next.length;
+        return next;
+    });
+    if (storage === 'memory')
+        console.error(`vault-go: chave local indisponível; ${held} cópia(s) pendente(s) para o Crystal mantida(s) só em memória.`);
+}
+/** Retries locked Crystal copies for this account, stopping at the first sign the Crystal is still locked or closed. */
+export async function flushPendingCrystalMirrors(home = vaultHome(), owner = ownerKey(home), options = {}) {
+    if (!existsSync(join(home, PENDING_MIRROR_STORE)) && !memoryMirrors.get(home)?.length)
+        return 0;
+    const openStore = options.openStore ?? privateStore;
+    const release = await lock(home, 'crystal-mirror-flush', false);
+    if (!release)
+        return 0;
+    let written = 0;
+    try {
+        const items = (await pendingCrystalMirrors(home, openStore)).filter(entry => entry.owner === owner).slice(0, options.limit ?? 25);
+        for (const item of items) {
+            const outcome = await writeCrystalMirror(home, { sourceId: item.sourceId, project: item.project, title: item.title, content: item.content, tags: item.tags });
+            if (outcome === 'locked' || outcome === 'unavailable')
+                break;
+            // Written, or rejected for a reason other than the lock: retrying would not help.
+            if (outcome === 'written')
+                written++;
+            await mutatePendingMirrors(home, openStore, current => current.filter(entry => entry.sourceId !== item.sourceId));
+        }
+    }
+    finally {
+        release();
+    }
+    return written;
+}
 export async function enqueueGeneration(home, job) {
     if (isUnusableGenerationText(job.text) || job.text.length > 16_000)
         return;
@@ -145,6 +253,7 @@ export async function processGenerationQueue(home = vaultHome(), cloud = new Vau
                 await mutate(home, jobs => jobs.map(item => !item.owner && owned.has(item.projectId) ? { ...item, owner } : item));
             }
         }
+        await flushPendingCrystalMirrors(home, owner, options.crystalMirrorStore ? { openStore: options.crystalMirrorStore } : {}).catch(() => 0);
         const job = readQueue(home).find(item => item.owner === owner && (item.nextAttemptAt ?? 0) <= Date.now());
         if (!job)
             return false;
@@ -178,7 +287,10 @@ export async function processGenerationQueue(home = vaultHome(), cloud = new Vau
             const awareness = await pushAwareness(home, { ...(job.agentId ? { agentId: job.agentId } : {}), observations: [{ type: awarenessType, title: result.title || job.title || 'Memória', facts: result.facts, concepts: result.concepts }] });
             if (awareness.error)
                 throw new Error('Awareness delivery failed; retry with cached generation.');
-            await mirrorCrystalMemory({ home, cloud, job, result });
+            const mirror = await mirrorCrystalMemory({ home, cloud, job, result });
+            // Never fail the cloud job over the Crystal copy; a locked Crystal just defers it.
+            if (mirror.outcome === 'locked' && mirror.record)
+                await queuePendingCrystalMirror(home, owner, mirror.record, options.crystalMirrorStore).catch(() => { });
             await mutate(home, jobs => jobs.filter(item => item.id !== job.id));
             if (job.kind === 'observation' && owner === ownerKey(home)) {
                 try {

package/dist/hook-runner.js

@@ -3,7 +3,7 @@ import { HOOK_EVENTS, runHook } from "./hooks.js";
 const adapter = process.argv[2] ?? "auto";
 const event = process.argv[3];
 if (!event || !HOOK_EVENTS.includes(event)) {
-    process.stderr.write("Uso: hook-runner <adaptador> context|session-init|observation|file-context|summarize\n");
+    process.stderr.write("Uso: hook-runner <adaptador> setup|context|session-init|observation|file-context|summarize|session-end\n");
     process.exit(1);
 }
 await runHook(adapter, event);

package/dist/hooks.d.ts

@@ -1,6 +1,6 @@
 export { redact } from './capture-privacy.js';
 import { type VaultMemoryApi } from "./cloud.js";
-export declare const HOOK_EVENTS: readonly ["context", "session-init", "observation", "file-context", "summarize"];
+export declare const HOOK_EVENTS: readonly ["setup", "context", "session-init", "observation", "file-context", "summarize", "session-end"];
 export type HookEvent = (typeof HOOK_EVENTS)[number];
 type RecordValue = Record<string, unknown>;
 /** The existing project for a working directory (worktrees map to their main checkout); never creates one. */

package/dist/hooks.js

@@ -10,12 +10,15 @@ import { vaultHome } from "./config.js";
 import { enqueueGeneration } from "./hook-queue.js";
 import { transcriptCaptureEnabled } from './transcript-config.js';
 import { loadProjectContext } from './context-chain.js';
+import { skillContextSection } from './skill-context.js';
 export const HOOK_EVENTS = [
+    "setup",
     "context",
     "session-init",
     "observation",
     "file-context",
     "summarize",
+    "session-end",
 ];
 const record = (value) => value && typeof value === "object" && !Array.isArray(value)
     ? value
@@ -190,6 +193,11 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
         /vault[_-]go|vault[_-]mem/.test(toolName)) {
         return hookOutput(event, "", adapter);
     }
+    if (event === "setup") {
+        const output = hookOutput(event, "", adapter);
+        output.systemMessage = "Vault Memory: hooks ready.";
+        return output;
+    }
     const prefs = await preferences(cloud);
     const reading = event === "context" || event === "file-context";
     if (!reading && prefs.automaticCapture !== true)
@@ -197,7 +205,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     const tool = record(input.tool_input);
     const file = string(tool.file_path, tool.path, tool.notebook_path, tool.AbsolutePath, tool.Path, tool.filePath);
     const modifies = /write|edit|patch|create|delete|move|rename/i.test(toolName);
-    if (!reading && prefs.captureMode === "focused" && event !== "summarize")
+    if (!reading && prefs.captureMode === "focused" && event !== "summarize" && event !== "session-end")
         return hookOutput(event, "", adapter);
     if (event === "observation" && prefs.captureMode === "balanced" && !modifies)
         return hookOutput(event, "", adapter);
@@ -246,6 +254,15 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
             })
             : { context: await loadProjectContext(home, cloud, { workspace, primary: { id: project.id }, projects, ...limits }) });
         let context = string(result.context).slice(0, limits.maxChars);
+        if (event === "context") {
+            // Skills do projeto entram depois da memória e só no espaço que sobrar; falha aqui nunca derruba o contexto.
+            try {
+                const skills = await skillContextSection(cloud, project.id);
+                if (skills && context.length + skills.length + 2 <= limits.maxChars)
+                    context = context ? `${context}\n\n${skills}` : skills;
+            }
+            catch { /* biblioteca de skills indisponível */ }
+        }
         try {
             context = applyCustomModeContext(home, context, limits.maxChars);
         }
@@ -270,8 +287,8 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
     }));
     const rawContent = event === "session-init"
         ? prompt
-        : event === "summarize"
-            ? response
+        : event === "summarize" || event === "session-end"
+            ? response || (event === "session-end" ? "session ended" : "")
             : JSON.stringify(toolPayload);
     const content = String(redact(rawContent));
     if (content.trim()) {
@@ -279,7 +296,9 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
             ? "user_prompt"
             : event === "summarize"
                 ? "session_summary"
-                : "tool_use";
+                : event === "session-end"
+                    ? "session_end"
+                    : "tool_use";
         const sourceEventId = createHash("sha256")
             .update(JSON.stringify([
             adapter,
@@ -306,7 +325,7 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
                 summaryMode: 'off',
                 metadata: { summaryMode: 'off' },
                 title: toolName ||
-                    (event === "summarize" ? "Resumo da sessão" : "Solicitação do usuário"),
+                    (event === "session-end" ? "Fim da sessão" : event === "summarize" ? "Resumo da sessão" : "Solicitação do usuário"),
                 content,
                 filesRead: !modifies ? files : [],
                 filesModified: modifies ? files : [],
@@ -321,14 +340,14 @@ export async function executeHook(adapter, event, value, cloud = new VaultCloudC
             ...(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",
+                (event === "session-end" ? "Fim da sessão" : event === "summarize" ? "Resumo da sessão" : "Solicitação do usuário"),
+            kind: event === "summarize" || event === "session-end" ? "summary" : event === "session-init" ? "prompt" : "observation",
             maxChars: boundedPreference(prefs.summaryMaxChars, 4_000, 256, 16_000),
             filesRead: !modifies ? files : [],
             filesModified: modifies ? files : [],
         });
     }
-    if (event === "summarize")
+    if (event === "summarize" || event === "session-end")
         await cloud.endSession(session.id);
     return hookOutput(event, "", adapter);
 }

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, runTranscripts, runContextChain } from './cli.js';
+import { cliArguments, helpText, resolveCliMode, runEngine, runLocal, runLogin, runSetup, runUpdate, runTranscripts, runContextChain, runSkills } from './cli.js';
 import { HOOK_EVENTS, runHook } from './hooks.js';
 import { createVaultGoServer, VERSION } from './server.js';
 const { argument, options } = cliArguments(process.argv.slice(2));
@@ -45,6 +45,10 @@ async function main() {
         process.exitCode = await runContextChain(options);
         return;
     }
+    if (mode === 'skills') {
+        process.exitCode = await runSkills(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, installOpenCodePlugin } from './hook-install.js';
+import { installCaptureHooks, installClientHooks, installOpenCodePlugin } from './hook-install.js';
 import { installManagedSkills } from './skill-install.js';
 export const MCP_SERVER_NAME = 'vault-go';
 export const MCP_SERVER_COMMAND = ['bunx', '--bun', 'vault-go@latest', 'serve'];
@@ -261,6 +261,13 @@ export function installMcpClient(client, options = {}) {
     else {
         mergeServer(path);
     }
+    if (client === 'cursor' || client === 'windsurf') {
+        try {
+            stageLocalRuntime(vaultHome());
+        }
+        catch { /* hooks still point at the staged runner when it exists */ }
+        installCaptureHooks(client, home);
+    }
     return { client, status: 'installed', destination: path };
 }
 export function detectMcpClients(home = homedir()) {

package/dist/legacy-brand.d.ts

@@ -0,0 +1,2 @@
+/** Caminho herdado do manifesto dentro do tar de um bundle de skills. */
+export declare const LEGACY_SKILL_BUNDLE_MANIFEST_PATH = "dev.orca.skill-sharing/manifest.json";

package/dist/legacy-brand.js

@@ -0,0 +1,5 @@
+// Por quê: o Vault Desktop nasceu de um fork de outro produto e ainda grava o
+// manifesto de bundle de skills no caminho herdado dele (os builds 0.2.x só
+// conhecem esse). Este é o único lugar onde o literal herdado pode morar.
+/** Caminho herdado do manifesto dentro do tar de um bundle de skills. */
+export const LEGACY_SKILL_BUNDLE_MANIFEST_PATH = 'dev.orca.skill-sharing/manifest.json';

package/dist/local-service.js

@@ -5,6 +5,7 @@ import { join } from "node:path";
 import { createHash, createHmac, randomBytes, timingSafeEqual, } from "node:crypto";
 import { authPath, loadConfig, loadTokens, vaultHome } from "./config.js";
 import { VaultCloudClient } from "./cloud.js";
+import { statuslineText } from "./agent-cost.js";
 import { readActivity } from "./activity.js";
 import { dashboardHtml, dashboardScript } from "./local-dashboard.js";
 import pkg from "../package.json" with { type: "json" };
@@ -336,6 +337,16 @@ export async function startLocalService(options = {}) {
             });
             return;
         }
+        if (url.pathname === "/statusline" && req.method === "GET") {
+            res.setHeader("Content-Type", "text/plain; charset=utf-8");
+            res.end(statuslineText(home, pkg.version));
+            return;
+        }
+        if (url.pathname === "/viewer" && req.method === "GET") {
+            res.setHeader("Content-Type", "text/html; charset=utf-8");
+            res.end(`<!doctype html><html lang="en"><head><meta charset="utf-8"><title>Vault Memory</title></head><body><h1>Vault Memory</h1><p>Search uses the Vault account index. This page does not keep a second local vector database.</p><p><a href="/">Open the dashboard</a></p><pre id="line"></pre><script>fetch("/statusline").then(function(response){return response.text()}).then(function(text){document.getElementById("line").textContent=text})</script></body></html>`);
+            return;
+        }
         if (url.pathname === "/" && req.method === "GET") {
             res.setHeader("Content-Type", "text/html; charset=utf-8");
             res.end(dashboardHtml());

package/dist/memory-archive.d.ts

@@ -0,0 +1,25 @@
+export interface ArchiveRecord {
+    sourceId: string;
+    kind: string;
+    content: string;
+    title?: string;
+    sessionId?: string;
+    memoryType?: string;
+    facts?: string[];
+    concepts?: string[];
+    filesRead?: string[];
+    filesModified?: string[];
+    occurredAt?: string;
+}
+export interface FourGroupArchive {
+    version: 1;
+    format: 'vault-memory-groups';
+    observations: ArchiveRecord[];
+    sessions: ArchiveRecord[];
+    summaries: ArchiveRecord[];
+    prompts: ArchiveRecord[];
+}
+export declare function normalizeArchiveRecord(value: unknown, fallbackId: string): ArchiveRecord | null;
+export declare function recordsFromExport(value: unknown): ArchiveRecord[];
+export declare function groupArchive(records: ArchiveRecord[]): FourGroupArchive;
+export declare function flattenArchive(archive: FourGroupArchive): ArchiveRecord[];

package/dist/memory-archive.js

@@ -0,0 +1,65 @@
+const GROUPS = ['observations', 'sessions', 'summaries', 'prompts'];
+function strings(value, max) {
+    if (!Array.isArray(value))
+        return undefined;
+    const items = value.filter((item) => typeof item === 'string' && item.trim().length > 0).map(item => item.trim().slice(0, 2_000)).slice(0, max);
+    return items.length ? items : undefined;
+}
+export function normalizeArchiveRecord(value, fallbackId) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const row = value;
+    const content = typeof row.content === 'string' ? row.content.trim() : typeof row.text === 'string' ? row.text.trim() : '';
+    if (!content)
+        return null;
+    const sourceId = typeof row.sourceId === 'string' && row.sourceId.trim() ? row.sourceId.trim().slice(0, 500) : fallbackId;
+    const kind = typeof row.kind === 'string' && row.kind.trim() ? row.kind.trim().slice(0, 100) : 'observation';
+    const record = { sourceId, kind, content: content.slice(0, 200_000) };
+    if (typeof row.title === 'string' && row.title.trim())
+        record.title = row.title.trim().slice(0, 500);
+    if (typeof row.sessionId === 'string' && row.sessionId.trim())
+        record.sessionId = row.sessionId.trim().slice(0, 80);
+    if (typeof row.memoryType === 'string' && row.memoryType.trim())
+        record.memoryType = row.memoryType.trim().slice(0, 100);
+    if (typeof row.occurredAt === 'string' && row.occurredAt.trim())
+        record.occurredAt = row.occurredAt.trim().slice(0, 40);
+    const facts = strings(row.facts, 200);
+    const concepts = strings(row.concepts, 200);
+    const filesRead = strings(row.filesRead, 500);
+    const filesModified = strings(row.filesModified, 500);
+    if (facts)
+        record.facts = facts;
+    if (concepts)
+        record.concepts = concepts;
+    if (filesRead)
+        record.filesRead = filesRead;
+    if (filesModified)
+        record.filesModified = filesModified;
+    return record;
+}
+function groupOf(kind) {
+    const value = kind.toLowerCase();
+    if (value === 'prompt' || value === 'user_prompt')
+        return 'prompts';
+    if (value === 'summary' || value === 'session_summary' || value === 'session_end')
+        return 'summaries';
+    if (value === 'session')
+        return 'sessions';
+    return 'observations';
+}
+export function recordsFromExport(value) {
+    const root = value && typeof value === 'object' ? value : {};
+    const lists = [root.records, root.memories, root.items].find(Array.isArray);
+    const grouped = GROUPS.flatMap(name => Array.isArray(root[name]) ? root[name] : []);
+    const source = lists ?? grouped;
+    return source.map((item, index) => normalizeArchiveRecord(item, `export-${index + 1}`)).filter((item) => Boolean(item)).slice(0, 4_000);
+}
+export function groupArchive(records) {
+    const archive = { version: 1, format: 'vault-memory-groups', observations: [], sessions: [], summaries: [], prompts: [] };
+    for (const record of records.slice(0, 4_000))
+        archive[groupOf(record.kind)].push(record);
+    return archive;
+}
+export function flattenArchive(archive) {
+    return GROUPS.flatMap(name => archive[name]).slice(0, 1_000);
+}

package/dist/modes.d.ts

@@ -1,5 +1,5 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-export declare const MODE_NAMES: readonly ["babysit", "mem-search", "how-it-works", "make-plan", "do", "smart-explore", "knowledge-agent", "standup", "timeline-report", "weekly-digests", "learn-codebase", "pathfinder", "design-is", "what-the", "version-bump", "oh-my-issues", "cloud-sync", "mode-creator", "ccs-align", "wowerpoint"];
+export declare const MODE_NAMES: readonly ["babysit", "mem-search", "how-it-works", "make-plan", "do", "smart-explore", "knowledge-agent", "standup", "timeline-report", "weekly-digests", "learn-codebase", "pathfinder", "design-is", "what-the", "version-bump", "oh-my-issues", "cloud-sync", "mode-creator", "ccs-align", "wowerpoint", "agent-cost-report"];
 export type VaultModeName = (typeof MODE_NAMES)[number];
 export type VaultModeStatus = 'native' | 'instructional' | 'limited';
 export interface VaultMode {

package/dist/modes.js

@@ -21,6 +21,7 @@ export const MODE_NAMES = [
     'mode-creator',
     'ccs-align',
     'wowerpoint',
+    'agent-cost-report',
 ];
 const mode = (name, title, summary, status, readOnlyDefault, runtimeRequires, limitations, steps) => ({
     name,
@@ -50,10 +51,11 @@ export const VAULT_MODES = [
     mode('what-the', 'Explain a technical subject plainly', 'Give a grounded who, what, where, why and when explanation without assuming specialist context.', 'native', true, ['The subject or artifact to explain', 'Vault Go retrieval or smart-code tools when evidence is needed'], ['The answer is limited by the supplied material and accessible evidence.', 'This mode does not mutate code or account state.'], ['Gather only the evidence needed to understand the named subject.', 'Explain who owns it, what it does, where it lives, why it exists and when it runs.', 'Use a concrete example and distinguish verified behavior from inference.']),
     mode('version-bump', 'Plan or perform a version bump', 'Audit release scope, update consistent version surfaces and verify a release when authorized.', 'limited', true, ['Local git and package tooling', 'gh or a connected GitHub provider for GitHub releases'], ['This mode does not execute registry publication itself.', 'Tags, releases, pushes and registry publication require explicit authorization in the current task.'], ['Inspect changes since the previous release and determine the semantic version impact.', 'Find version manifests and changelog conventions, then propose or apply consistent updates as requested.', 'Run build and tests; create tags, releases or remote changes only when the request explicitly includes them.']),
     mode('oh-my-issues', 'Cluster an issue backlog', 'Group related issues by root cause and design a small set of architectural fixes.', 'limited', true, ['gh or a connected GitHub provider', 'Read access to the requested issue tracker'], ['Vault Go has no built-in issue tracker client.', 'Comments, issue edits, closures and pull requests require explicit authorization in the current task.'], ['Collect a bounded issue set and normalize symptoms, affected areas and reproduction evidence.', 'Cluster issues by verified shared cause, keeping ambiguous reports separate.', 'Draft plan-master issues and routing actions; write them to GitHub only when requested.']),
-    mode('cloud-sync', 'Inspect cloud and sync options', 'Explain Vault account connectivity and inspect available status without pretending to implement another service.', 'limited', true, ['vault_go_status', 'vault_go_cloud_health', 'vault_go_preferences'], ['The cmem.ai cloud-sync protocol is not implemented by Vault Go; Vault cloud is a separate service.', 'This mode does not sign in, enable sync or change preferences unless the request explicitly asks for that action.'], ['Read account and preference status to establish what this Vault runtime can access.', 'Explain the boundary between local capture, Vault service storage and unsupported cmem.ai sync.', 'If the user explicitly requests a supported configuration change, use only the relevant available Vault tool and report its result.']),
+    mode('cloud-sync', 'Inspect cloud and sync options', 'Explain Vault account connectivity and inspect available status without pretending to implement another service.', 'limited', true, ['vault_go_status', 'vault_go_cloud_health', 'vault_go_preferences'], ['Vault cloud is the account store. External sync protocols are not part of this runtime.', 'This mode does not sign in, enable sync or change preferences unless the request explicitly asks for that action.'], ['Read account and preference status to establish what this Vault runtime can access.', 'Explain the boundary between local capture and Vault service storage.', 'If the user explicitly requests a supported configuration change, use only the relevant available Vault tool and report its result.']),
     mode('mode-creator', 'Design a custom mode', 'Create and activate a bounded observation taxonomy with inherited prompts and optional Telegram triggers.', 'native', true, ['vault_go_custom_mode_save', 'vault_go_custom_mode_select', 'vault_go_telegram_configure'], ['A custom mode applies to future local context generation; it does not rewrite existing memories.', 'Telegram credentials must be supplied through the private service environment, never prompt or tool arguments.'], ['Learn what should be recorded and skipped, then propose distinct observation types and reusable concept tags.', 'After the user approves the taxonomy, save it with vault_go_custom_mode_save and activate it with vault_go_custom_mode_select.', 'Configure Telegram triggers only when explicitly requested, then use vault_go_telegram_test for the one authorized test message.']),
     mode('ccs-align', 'Run an alignment review', 'Run a Vault-native alignment cycle with an isolated cache, reversible exclusions and cascade-rule reporting.', 'native', true, ['vault_go_ccs_align_health', 'vault_go_ccs_align_cycle', 'vault_go_ccs_align_rules_check'], ['Vault uses cloud UUIDs and its own private cache rather than the upstream numeric worker diary.', 'Grok Bot awareness push is a separate agent-log writer and is not implemented by CCS Align.'], ['Check viewer health, then run vault_go_ccs_align_cycle to retrieve index, timeline and selected observations in order.', 'Use exclude and restore tools to filter only the compiled viewer cache; never delete authoritative cloud memory.', 'Submit bounded house, project and seat rule lines to vault_go_ccs_align_rules_check and review the append-only report.']),
     mode('wowerpoint', 'Outline a narrative slide deck', 'Transform one source document into a structured, audience-aware slide narrative.', 'limited', true, ['One source document', 'A client presentation or document renderer for a final artifact'], ['PPTX or PDF rendering is not implemented by Vault Go.', 'Vault Go can return a slide outline and art direction but cannot claim a generated deck file.'], ['Identify the audience, core claim and evidence in the source document.', 'Create a concise slide sequence with titles, key points, visual direction and speaker intent.', 'Render a presentation only if the client exposes a suitable tool and the user asks for the artifact.']),
+    mode('agent-cost-report', 'Report agent cost', 'Estimate transcript token cost for a local directory and keep missing prices unavailable.', 'native', true, ['vault_go_agent_cost_report'], ['Dollars are a public list estimate, not a provider invoice.', 'Grok and other clients without usage fields stay unavailable instead of being shown as zero.'], ['Choose the transcript directory the user asked to measure.', 'Call vault_go_agent_cost_report and keep the ESTIMATED label on every dollar figure.', 'Report token totals, the files scanned, and any unavailable sources without inventing a zero.']),
 ];
 const TASK_MAX_CHARS = 4_000;
 const taskSchema = z.string().trim().min(1).max(TASK_MAX_CHARS).optional();

package/dist/opencode-plugin.d.ts

@@ -3,7 +3,7 @@ type Options = {
     fetch?: typeof fetch;
     timeoutMs?: number;
 };
-/** OpenCode 1.x plugin contract: context only; capture stays with the user's existing integrations. */
+/** OpenCode 1.x plugin: inject context and capture prompts, tool use and session end. */
 export declare function createOpenCodePlugin(input: {
     directory: string;
 }, options?: Options): {
@@ -12,5 +12,33 @@ export declare function createOpenCodePlugin(input: {
     }, output: {
         system: string[];
     }) => Promise<void>;
+    'chat.message': (_input: {
+        sessionID?: string;
+    }, output: {
+        parts?: Array<{
+            type?: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    'tool.execute.before': (toolInput: {
+        tool?: string;
+        sessionID?: string;
+    }, output: {
+        args?: Record<string, unknown>;
+    }) => Promise<void>;
+    'tool.execute.after': (toolInput: {
+        tool?: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        args?: Record<string, unknown>;
+        output?: unknown;
+    }) => Promise<void>;
+    event: ({ event }: {
+        event?: {
+            type?: string;
+            properties?: Record<string, unknown>;
+        };
+    }) => Promise<void>;
 };
 export {};