specmem-hardwicksoftware 3.7.35 → 3.7.36

package/dist/mcp/embeddingServerManager.js

@@ -187,6 +187,8 @@ export class EmbeddingServerManager extends EventEmitter {
             this.isRunning = true;
             return true;
         }
+        // Refresh socket path before start to pick up any externally-created sockets
+        this.refreshSocketPath();
         if (this.isRunning) {
             logger.debug('[EmbeddingServerManager] Server already running');
             return true;
@@ -1119,6 +1121,8 @@ export class EmbeddingServerManager extends EventEmitter {
         this.isShuttingDown = true;
         this.isStarting = false; // Reset starting flag on stop
         this.startupGraceUntil = 0; // Clear any active grace period
+        // Refresh socket path to find actual socket before stopping
+        this.refreshSocketPath();
         logger.info('[EmbeddingServerManager] Stopping embedding server...');
         // Stop health monitoring
         this.stopHealthMonitoring();
@@ -1186,6 +1190,8 @@ export class EmbeddingServerManager extends EventEmitter {
      */
     async healthCheck() {
         const startTime = Date.now();
+        // Refresh socket path to find socket that may have appeared after construction
+        this.refreshSocketPath();
         // Quick check: socket must exist
         if (!existsSync(this.socketPath)) {
             return {
@@ -1300,11 +1306,54 @@ export class EmbeddingServerManager extends EventEmitter {
     /**
      * Get current server status
      */
+    /**
+     * Refresh socketPath by re-scanning known locations.
+     * Ensures we pick up a socket that appeared after construction.
+     */
+    refreshSocketPath() {
+        try {
+            const freshPath = getEmbeddingSocketPath();
+            if (freshPath && freshPath !== this.socketPath) {
+                logger.debug({ old: this.socketPath, new: freshPath }, '[EmbeddingServerManager] Socket path updated');
+                this.socketPath = freshPath;
+                this.pidFilePath = join(dirname(freshPath), 'embedding.pid');
+                this.stoppedFlagPath = join(dirname(freshPath), 'embedding.stopped');
+            }
+        }
+        catch (err) {
+            logger.debug({ error: err.message }, '[EmbeddingServerManager] refreshSocketPath failed');
+        }
+    }
+    /**
+     * Check if the PID from the PID file is alive (signal 0 check).
+     */
+    isPidAlive(pid) {
+        if (!pid || pid <= 0)
+            return false;
+        try {
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
     getStatus() {
+        // Refresh socket path to pick up sockets that appeared after construction
+        this.refreshSocketPath();
         const pid = this.readPidFile();
         const socketExists = existsSync(this.socketPath);
+        // Determine running state: use in-memory flag OR check PID file + process alive
+        // This handles the case where server is running but manager was freshly created
+        const running = this.isRunning || (pid != null && this.isPidAlive(pid) && socketExists);
+        // Sync in-memory flag if we detected a running server via PID
+        if (running && !this.isRunning && pid != null) {
+            this.isRunning = true;
+            this.startTime = this.startTime || Date.now();
+            logger.info({ pid }, '[EmbeddingServerManager] Detected running server from PID file, syncing state');
+        }
         return {
-            running: this.isRunning,
+            running,
             pid,
             socketPath: this.socketPath,
             socketExists,
@@ -2009,6 +2058,9 @@ export class EmbeddingServerManager extends EventEmitter {
         // Phase 1: Wait for socket file to appear (use 50% of timeout for file appearance)
         const fileWaitDeadline = startTime + (this.config.startupTimeoutMs * 0.5);
         while (Date.now() < fileWaitDeadline) {
+            // Refresh socket path each iteration — the socket may appear at a path
+            // different from what was computed at construction time
+            this.refreshSocketPath();
             if (existsSync(this.socketPath)) {
                 logger.debug({ elapsed: Date.now() - startTime }, '[EmbeddingServerManager] Socket file appeared, starting health check polling');
                 break;
@@ -2672,6 +2724,14 @@ export function getEmbeddingServerManager(config) {
     }
     // Create new manager for this project
     const manager = new EmbeddingServerManager(config);
+    // Recover state from PID file if server is already running externally
+    // This handles the case where manager is recreated but server is still alive
+    const existingPid = manager.readPidFile();
+    if (existingPid && manager.isPidAlive(existingPid) && existsSync(manager.socketPath)) {
+        manager.isRunning = true;
+        manager.startTime = Date.now();
+        logger.info({ pid: existingPid, socketPath: manager.socketPath }, '[EmbeddingServerManager] Recovered running state from existing PID file');
+    }
     embeddingManagersByProject.set(projectPath, manager);
     logger.info({ projectPath, totalManagers: embeddingManagersByProject.size }, '[EmbeddingServerManager] Created new per-project manager');
     return manager;

package/dist/mcp/mcpProtocolHandler.js

@@ -388,8 +388,13 @@ export class MCPProtocolHandler {
             // validate inputs if we have a schema
             const schema = TOOL_SCHEMAS[toolName];
             let validatedArgs = args;
+            // Strip proxy artifacts before validation — compaction proxy sometimes injects _stripped
+            if (validatedArgs && typeof validatedArgs === 'object' && '_stripped' in validatedArgs) {
+                const { _stripped, ...clean } = validatedArgs;
+                validatedArgs = clean;
+            }
             if (schema) {
-                const result = schema.safeParse(args);
+                const result = schema.safeParse(validatedArgs);
                 if (!result.success) {
                     throw new Error(`validation failed fr: ${result.error.message}`);
                 }

package/dist/mcp/miniCOTServerManager.js

@@ -28,7 +28,7 @@
  * @author hardwicksoftwareservices
  */
 import { spawn, execSync } from 'child_process';
-import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, renameSync } from 'fs';
 import { join, dirname } from 'path';
 import { createConnection } from 'net';
 import { EventEmitter } from 'events';
@@ -220,6 +220,18 @@ export class MiniCOTServerManager extends EventEmitter {
                 this.startTime = Date.now();
                 this.consecutiveFailures = 0;
                 this.isStarting = false;
+                // Clean stale PID file — we don't own this process
+                const stalePid = this.readPidFile();
+                if (stalePid) {
+                    try {
+                        process.kill(stalePid, 0);
+                    }
+                    catch (_e) {
+                        // Stale PID — remove it
+                        this.removePidFile();
+                        logger.debug({ stalePid }, '[MiniCOTServerManager] Removed stale PID file for dead process while adopting external server');
+                    }
+                }
                 this.emit('started', { pid: null, external: true });
                 return true;
             }
@@ -231,6 +243,17 @@ export class MiniCOTServerManager extends EventEmitter {
             catch (err) {
                 logger.warn({ error: err }, '[MiniCOTServerManager] Failed to remove old socket');
             }
+            // Also clean stale PID file if process is dead
+            const stalePid = this.readPidFile();
+            if (stalePid) {
+                try {
+                    process.kill(stalePid, 0);
+                }
+                catch (_e) {
+                    this.removePidFile();
+                    logger.debug({ stalePid }, '[MiniCOTServerManager] Removed stale PID file for dead process during startup cleanup');
+                }
+            }
         }
         // Find the Mini COT script
         const miniCOTScript = this.findMiniCOTScript();
@@ -376,7 +399,21 @@ export class MiniCOTServerManager extends EventEmitter {
             return true;
         }
         catch (err) {
-            logger.error({ error: err }, '[MiniCOTServerManager] Failed to start server');
+            const errMsg = err?.message || String(err);
+            const isEADDRINUSE = errMsg.includes('EADDRINUSE') || errMsg.includes('address already in use');
+            const isENOENT = errMsg.includes('ENOENT') || errMsg.includes('no such file');
+            const isEACCES = errMsg.includes('EACCES') || errMsg.includes('permission denied');
+            let hint = '';
+            if (isEADDRINUSE) {
+                hint = ` (socket ${this.socketPath} already in use — another Mini COT instance may be running)`;
+            }
+            else if (isENOENT) {
+                hint = ` (Mini COT script not found — check installation)`;
+            }
+            else if (isEACCES) {
+                hint = ` (permission denied — check file permissions on script or socket directory)`;
+            }
+            logger.error({ error: err, socketPath: this.socketPath }, `[MiniCOTServerManager] Failed to start server${hint}`);
             this.isStarting = false;
             return false;
         }
@@ -424,11 +461,12 @@ export class MiniCOTServerManager extends EventEmitter {
                 logger.debug({ error: err }, '[MiniCOTServerManager] Failed to remove socket');
             }
         }
+        const stoppedPid = this.process?.pid ?? null;
         this.process = null;
         this.isRunning = false;
         this.startTime = null;
         logger.info('[MiniCOTServerManager] Server stopped');
-        this.emit('stopped', { pid: this.process?.pid });
+        this.emit('stopped', { pid: stoppedPid });
     }
     /**
      * Perform a health check on the Mini COT server
@@ -529,12 +567,31 @@ export class MiniCOTServerManager extends EventEmitter {
     getStatus() {
         const pid = this.readPidFile();
         const socketExists = existsSync(this.socketPath);
+        // Check actual process liveness, not just in-memory flag
+        let processAlive = false;
+        if (pid) {
+            try {
+                process.kill(pid, 0); // signal 0 = existence check
+                processAlive = true;
+            }
+            catch (_e) {
+                // Process does not exist
+                processAlive = false;
+            }
+        }
+        // Reconcile: if isRunning but process is dead, correct the state
+        const actuallyRunning = this.isRunning && processAlive;
+        if (this.isRunning && !processAlive && pid) {
+            logger.warn({ pid }, '[MiniCOTServerManager] getStatus: process dead but isRunning was true, correcting state');
+            this.isRunning = false;
+        }
         return {
-            running: this.isRunning,
+            running: actuallyRunning,
             pid,
+            processAlive,
             socketPath: this.socketPath,
             socketExists,
-            healthy: this.isRunning && socketExists && this.consecutiveFailures === 0,
+            healthy: actuallyRunning && socketExists && this.consecutiveFailures === 0,
             lastHealthCheck: this.healthCheckTimer ? Date.now() : null,
             consecutiveFailures: this.consecutiveFailures,
             restartCount: this.restartCount,
@@ -1184,6 +1241,14 @@ export class MiniCOTServerManager extends EventEmitter {
             logger.debug({ pid: healthInfo.pid }, '[MiniCOTServerManager] Process from PID file no longer exists');
         }
         this.removePidFile();
+        // Also clean up stale socket
+        try {
+            if (existsSync(this.socketPath)) {
+                unlinkSync(this.socketPath);
+                logger.debug('[MiniCOTServerManager] Cleaned up stale socket in killByPidFile');
+            }
+        }
+        catch (_e) { /* ignore */ }
     }
     /**
      * Find the Mini COT script path
@@ -1237,6 +1302,8 @@ export class MiniCOTServerManager extends EventEmitter {
         if (this.process) {
             this.process = null;
         }
+        // Always clean up PID file on exit to prevent stale PIDs
+        this.removePidFile();
         if (this.isShuttingDown) {
             // Expected exit during shutdown
             return;
@@ -1392,9 +1459,11 @@ export class MiniCOTServerManager extends EventEmitter {
             if (!existsSync(pidDir)) {
                 mkdirSync(pidDir, { recursive: true });
             }
-            // Format: PID:TIMESTAMP
-            writeFileSync(this.pidFilePath, `${pid}:${Date.now()}`, 'utf8');
-            logger.debug({ pid, path: this.pidFilePath }, '[MiniCOTServerManager] Wrote PID file');
+            // Format: PID:TIMESTAMP — atomic write via rename to prevent partial reads
+            const tmpPath = this.pidFilePath + '.tmp';
+            writeFileSync(tmpPath, `${pid}:${Date.now()}`, 'utf8');
+            renameSync(tmpPath, this.pidFilePath);
+            logger.debug({ pid, path: this.pidFilePath }, '[MiniCOTServerManager] Wrote PID file (atomic)');
         }
         catch (err) {
             logger.error({ error: err }, '[MiniCOTServerManager] Failed to write PID file');
@@ -1425,6 +1494,11 @@ export class MiniCOTServerManager extends EventEmitter {
                 unlinkSync(this.pidFilePath);
                 logger.debug('[MiniCOTServerManager] Removed PID file');
             }
+            // Also clean up any leftover .tmp from atomic write
+            const tmpPath = this.pidFilePath + '.tmp';
+            if (existsSync(tmpPath)) {
+                unlinkSync(tmpPath);
+            }
         }
         catch (err) {
             logger.debug({ error: err }, '[MiniCOTServerManager] Failed to remove PID file');

package/dist/mcp/specMemServer.js

@@ -85,7 +85,9 @@ import { getSkillScanner } from '../skills/skillScanner.js';
 import { getSkillResourceProvider } from '../skills/skillsResource.js';
 import { getSkillReminder } from '../reminders/skillReminder.js';
 // Compaction proxy — MITM token stripper for faster compaction
-import { startCompactionProxy, stopCompactionProxy, killCompactionProxy } from './compactionProxy.js';
+import { startCompactionProxy, stopCompactionProxy, killCompactionProxy, registerWithDaemon, checkDaemonHealth } from './compactionProxy.js';
+// Context vault — token-saving stash for thicc tool outputs (auto-stash + search)
+import { initContextVault, stashTheGoods as vaultStash, formatVaultReceipt, VAULT_THRESHOLD, VAULT_SKIP_TOOLS } from './contextVault.js';
 // Command loader - load command .md files as MCP prompts
 import { getCommandLoader } from '../commands/commandLoader.js';
 // CLI Notifications - centralized notification system
@@ -586,6 +588,25 @@ export class SpecMemServer {
                     __debugLog('[MCP DEBUG]', Date.now(), 'TOOL_SLOW_WARNING', { callId, toolName: name, durationMs: duration, threshold: 100 });
                     logger.warn({ duration, tool: name }, 'tool execution kinda slow ngl');
                 }
+                // === Auto-vault large tool results to save tokens ===
+                // If a tool returns >5KB, stash it and hand back a compact receipt.
+                // Claude can dig_in_the_vault later for specific data.
+                if (!VAULT_SKIP_TOOLS.has(name)) {
+                    try {
+                        const resultStr = typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+                        if (resultStr.length > VAULT_THRESHOLD) {
+                            const vaultResult = await vaultStash(resultStr, { tool: name, callId });
+                            if (!vaultResult.deduplicated) {
+                                startupLog(`[VAULT] Auto-stashed ${name}: ${resultStr.length} chars → receipt (vault:${vaultResult.vaultId})`);
+                            }
+                            result = formatVaultReceipt(vaultResult);
+                        }
+                    }
+                    catch (vaultErr) {
+                        // Non-fatal — fall through with original result
+                        __debugLog('[MCP DEBUG]', Date.now(), 'AUTO_VAULT_FAILED', { callId, toolName: name, error: vaultErr.message });
+                    }
+                }
                 __debugLog('[MCP DEBUG]', Date.now(), 'FORMATTING_RESPONSE', { callId, toolName: name });
                 const formattedResponse = this.formatResponse(result);
                 __debugLog('[MCP DEBUG]', Date.now(), 'RESPONSE_FORMATTED', {
@@ -1250,20 +1271,23 @@ export class SpecMemServer {
         // Each step waits for the previous to complete + yields to event loop
         // This prevents CPU spikes that cause MCP connection timeouts
         logger.info('SpecMem MCP server connected — lazy init starting');
-        // Step 2.5: Compaction Proxy — lightweight HTTP server, starts in <100ms
-        // Sits between Claude Code and Anthropic API, strips tool_result bodies
-        // from compaction requests (50-80% token reduction = faster compaction)
+        // Step 2.5: Register with compaction proxy daemon (DO NOT spawn here)
+        // The proxy daemon is started by specmem-init BEFORE Claude launches.
+        // By the time oninitialized fires, Claude is already running and routing
+        // traffic through ANTHROPIC_BASE_URL — spawning here is too late.
+        // We just register this project so the daemon knows we're alive.
         try {
-            const proxyResult = await startCompactionProxy();
-            if (proxyResult.started) {
-                startupLog(`Compaction proxy started on port ${proxyResult.port}`);
-                logger.info({ port: proxyResult.port }, 'Compaction proxy started');
+            const healthy = await checkDaemonHealth();
+            if (healthy) {
+                registerWithDaemon(process.env.SPECMEM_PROJECT_PATH, process.pid);
+                startupLog('Registered with existing compaction proxy daemon');
+                logger.info('Registered with compaction proxy daemon');
             } else {
-                startupLog(`Compaction proxy skipped: ${proxyResult.reason}`);
+                startupLog('Compaction proxy daemon not running — skipping registration (must be started by specmem-init)');
             }
         } catch (proxyErr) {
             // Non-fatal — proxy is optional, compaction still works without it
-            startupLog('Compaction proxy failed to start (non-fatal)', proxyErr);
+            startupLog('Compaction proxy registration check failed (non-fatal)', proxyErr);
         }
         // Step 3: Database init (deferred, tools wait via waitForReady())
         startupLog('Starting deferred database initialization...');
@@ -1928,6 +1952,17 @@ export class SpecMemServer {
                 // Non-fatal - tools can still work with in-memory fallback
                 logger.warn({ error: teamCommsError }, 'Team comms DB init failed - using in-memory fallback');
             }
+            // Initialize context vault for token-saving auto-stash
+            try {
+                if (pool) {
+                    initContextVault(pool, process.env['SPECMEM_PROJECT_PATH'] || '/');
+                    logger.info('Context vault initialized — auto-stash ready');
+                }
+            }
+            catch (vaultError) {
+                // Non-fatal — auto-stash disabled, manual tools still work
+                logger.warn({ error: vaultError }, 'Context vault init failed — auto-stash disabled');
+            }
             // FIX 1.02: Create CommandHandler AFTER DB is initialized
             // Previously created in constructor with uninitialized db
             // ORDERING INVARIANT (CRIT-1): commandHandler MUST be created here in deferredInit(),

package/dist/mcp/toolRegistry.js

@@ -57,6 +57,9 @@ import { GetMemoryFull } from '../tools/goofy/getMemoryFull.js';
 // Import project memory import/export tools - carry context across projects
 import { ImportProjectMemories } from '../tools/goofy/importProjectMemories.js';
 import { ExportProjectMemories } from '../tools/goofy/exportProjectMemories.js';
+// Import context vault tools - token-saving stash for thicc tool outputs
+import { StashTheGoods } from '../tools/goofy/stashTheGoods.js';
+import { DigInTheVault } from '../tools/goofy/digInTheVault.js';
 // Import MCP-based team communication tools (NEW - replaces HTTP team member comms)
 import { createTeamCommTools } from './tools/teamComms.js';
 // Import embedding server control tools (Phase 4 - user start/stop/status)
@@ -543,6 +546,9 @@ export function createToolRegistry(db, embeddingProvider) {
     // Project memory import/export tools - carry context across projects
     registry.register(new ImportProjectMemories(db, cachingProvider));
     registry.register(new ExportProjectMemories(db));
+    // Context vault tools - token-saving stash + search for thicc tool outputs
+    registry.register(new StashTheGoods());
+    registry.register(new DigInTheVault());
     // Team communication tools - multi-team member coordination
     const teamCommTools = createTeamCommTools();
     for (const tool of teamCommTools) {

package/dist/startup/startupIndexing.js

@@ -183,6 +183,16 @@ export async function triggerBackgroundIndexing(embeddingProvider, options = {})
     }
     state.indexingInProgress = true;
     state.lastIndexingCheck = new Date();
+    // Pause file watcher queue during indexing to avoid resource contention
+    let watcherQueue = null;
+    try {
+        const { getWatcherManager } = await import('../mcp/watcherIntegration.js');
+        const mgr = getWatcherManager();
+        if (mgr?.queue) {
+            watcherQueue = mgr.queue;
+            watcherQueue.pause('background indexing');
+        }
+    } catch { /* watcher not initialized yet — that's fine */ }
     try {
         const db = getDatabase();
         if (!db) {
@@ -241,6 +251,10 @@ export async function triggerBackgroundIndexing(embeddingProvider, options = {})
     }
     finally {
         state.indexingInProgress = false;
+        // Resume watcher queue after indexing completes (or fails)
+        if (watcherQueue) {
+            watcherQueue.resume();
+        }
     }
 }
 /**

package/dist/team-members/taskOrchestrator.js

@@ -1,8 +1,8 @@
 /**
- * Task Orchestrator - Smart Work Distribution System
+ * Agent Orchestrator - Smart Work Distribution System
  *
- * Provides intelligent task distribution to teamMembers:
- * - Task queue with priority management
+ * Provides intelligent agent distribution to teamMembers:
+ * - Agent queue with priority management
  * - Capability-based task matching
  * - Load balancing across team members
  * - Automatic failover and task reassignment

package/dist/team-members/taskTeamMemberLogger.js

@@ -1,7 +1,7 @@
 /**
- * taskTeamMemberLogger.ts - Logs  Code Task team member activity to SpecMem database
+ * taskTeamMemberLogger.ts - Logs  Code Agent team member activity to SpecMem database
  *
- * yo fr fr this bridges the gap between  Code's Task tool and SpecMem tracking
+ * yo fr fr this bridges the gap between  Code's Agent tool and SpecMem tracking
  *
  * Problem: Task-deployed team members are invisible to SpecMem dashboard
  * Solution: Log team member activity before/after Task deployment

package/dist/tools/goofy/deployTeamMember.js

@@ -1,8 +1,8 @@
 /**
- * deployTeamMember - The Task tool but actually works with MCP
+ * deployTeamMember - The Agent tool but actually works with MCP
  *
  * Spawns team members in screen sessions with full SpecMem MCP access.
- * This is basically skidding  Code's Task tool but making it not suck.
+ * This is basically skidding  Code's Agent tool but making it not suck.
  */
 import { deployTeamMember as deployTeamMemberImpl } from '../teamMemberDeployer.js';
 import { logger } from '../../utils/logger.js';
@@ -10,7 +10,7 @@ export class DeployTeamMember {
     name = 'deployTeamMember';
     description = `Deploy a team member with full SpecMem MCP access.
 
-This is like the Task tool but actually works - spawned team members get full access
+This is like the Agent tool but actually works - spawned team members get full access
 to all SpecMem MCP tools including team member communication (sayToTeamMember, listenForMessages,
 sendHeartbeat, getActiveTeamMembers).
 

package/dist/tools/goofy/digInTheVault.js

@@ -0,0 +1,81 @@
+/**
+ * digInTheVault - search the context vault for stashed content
+ *
+ * when you need to find something in all that stashed content
+ * without loading it all into context. BM25-ranked via tsvector.
+ *
+ * supports:
+ *   - query search across all vaults (project-scoped)
+ *   - targeted search within a specific vault_id
+ *   - full dump of a vault_id (get_all mode)
+ *   - stats mode (no query = return vault statistics)
+ */
+
+import { digInTheVault as doTheDig, getFullStash, getVaultStats } from '../../mcp/contextVault.js';
+
+export class DigInTheVault {
+  name = 'dig_in_the_vault';
+  description = 'Search the context vault for previously stashed content. Returns BM25-ranked chunks matching your query. Use vault_id to search a specific stash, or omit to search all. Use get_all:true to retrieve everything from a vault.';
+
+  inputSchema = {
+    type: 'object',
+    properties: {
+      query: {
+        type: 'string',
+        description: 'What to search for in the vault'
+      },
+      vault_id: {
+        type: 'string',
+        description: 'Search within a specific stash (the id from vault_receipt)'
+      },
+      limit: {
+        type: 'number',
+        description: 'Max results to return (default: 10)',
+        default: 10
+      },
+      get_all: {
+        type: 'boolean',
+        description: 'Retrieve ALL chunks for a vault_id in order (ignores query)',
+        default: false
+      }
+    }
+  };
+
+  async execute(params) {
+    const { query, vault_id, limit = 10, get_all = false } = params;
+
+    try {
+      // get_all mode: dump full stash content
+      if (get_all && vault_id) {
+        const full = await getFullStash(vault_id);
+        if (!full) return `<vault_dig ok="false" error="vault ${vault_id} not found or expired"/>`;
+        return full;
+      }
+
+      // No query = return vault stats
+      if (!query) {
+        const stats = await getVaultStats();
+        return JSON.stringify(stats, null, 2);
+      }
+
+      // BM25-ranked search
+      const results = await doTheDig(query, vault_id || null, limit);
+
+      if (results.length === 0) {
+        return vault_id
+          ? `<vault_dig ok="false" vault_id="${vault_id}" query="${query}" error="no matches — try different terms or get_all:true"/>`
+          : `<vault_dig ok="false" query="${query}" error="no matches in any vault"/>`;
+      }
+
+      // Format results compactly
+      const lines = results.map((r, i) => {
+        const header = `── [${i + 1}] vault:${r.vault_id} chunk:${r.chunk_idx} rank:${parseFloat(r.rank).toFixed(3)} ──`;
+        return `${header}\n${r.content}`;
+      });
+
+      return lines.join('\n\n');
+    } catch (err) {
+      return `<vault_dig ok="false" error="${err.message}"/>`;
+    }
+  }
+}

package/dist/tools/goofy/stashTheGoods.js

@@ -0,0 +1,56 @@
+/**
+ * stashTheGoods - manually vault content for later retrieval
+ *
+ * when you got data that's too thicc for the context window
+ * but you might need it later, stash it in the vault fr
+ *
+ * auto-stash handles most cases, but this tool lets claude
+ * manually stash anything it wants to keep searchable
+ */
+
+import { stashTheGoods as doTheStash, formatVaultReceipt } from '../../mcp/contextVault.js';
+
+export class StashTheGoods {
+  name = 'stash_the_goods';
+  description = 'Stash large content in the context vault for token-efficient retrieval later. Content is chunked, indexed with full-text search, and retrievable via dig_in_the_vault. Auto-expires after 24h.';
+
+  inputSchema = {
+    type: 'object',
+    properties: {
+      content: {
+        type: 'string',
+        description: 'The content to stash in the vault'
+      },
+      tool_name: {
+        type: 'string',
+        description: 'Which tool produced this content (for tracking)'
+      },
+      tags: {
+        type: 'array',
+        items: { type: 'string' },
+        description: 'Optional tags for categorization'
+      }
+    },
+    required: ['content']
+  };
+
+  async execute(params) {
+    const { content, tool_name, tags } = params;
+
+    if (!content || content.length === 0) {
+      return '<vault_receipt ok="false" error="nothing to stash fr"/>';
+    }
+
+    try {
+      const result = await doTheStash(content, {
+        tool: tool_name || 'manual_stash',
+        tags: tags || [],
+        manual: true,
+      });
+
+      return formatVaultReceipt(result);
+    } catch (err) {
+      return `<vault_receipt ok="false" error="${err.message}"/>`;
+    }
+  }
+}

package/dist/tools/teamMemberDeployer.js

@@ -1,7 +1,7 @@
 /**
  * Team Member Deployer Tool
  *
- * "Skidded" version of  Code's Task tool that actually works with MCP
+ * "Skidded" version of  Code's Agent tool that actually works with MCP
  * Spawns team members with full SpecMem MCP access
  *
  * Now integrates with TeamCommsService for team-based team member coordination:
@@ -23,7 +23,7 @@ import { getAgentsJson, isValidAgentType } from './agentDefinitions.js';
 /**
  * Deploy a team member with full SpecMem MCP access
  *
- * This is basically the Task tool but it actually fucking works
+ * This is basically the Agent tool but it actually fucking works
  * because we spawn team members with MCP configured
  *
  * Now with team communication support for coordinated multi-team-member work