cuemap-mcp 0.7.0 → 0.7.2

package/README.md

@@ -1,10 +1,10 @@
-# CueMap MCP Server
+# CueMap MCP Server v0.7.2
 
 The [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) server for CueMap, allowing AI coding assistants (like Claude Desktop, Cursor, Windsurf, and Antigravity) to instantly recall codebase context using the CueMap engine.
 
 ## Zero-Config Deployment
 
-The CueMap MCP Server is designed to work completely out-of-the-box. When started, it automatically manages a high-performance Rust instance of the CueMap Server in the background.
+The CueMap MCP Server is designed to work completely out-of-the-box. When started, it automatically manages a high-performance Rust instance of the CueMap Server in the background. The v0.7.2 engine bundles qint8 MiniLM-L3 by default and q4 MiniLM-L3 for the edge profile; no model download occurs at runtime.
 
 You do **not** need to install or run the CueMap CLI manually. The correct pre-compiled binary for your operating system is automatically downloaded via optional NPM dependencies.
 
@@ -24,6 +24,12 @@ By default, the embedded engine runs on port `8080`. You can customize the serve
 - `CUEMAP_PORT`: Override the port the embedded engine binds to (default: `8080`).
 - `CUEMAP_CONFIG_PATH`: Absolute path to a custom `server_config.toml` to configure advanced Engine tuning, background jobs, and RAG search parameters.
 - `CUEMAP_URL`: If you prefer to bypass the embedded engine and connect to a remotely hosted or separately running CueMap server, specify its URL here (e.g. `http://localhost:8080`).
+- `CUEMAP_PROJECT`: Override the default project. Without this setting, CueMap derives a stable repository-scoped project from the current Git remote or working directory.
+- `CUEMAP_LOG_PATH`: Override the embedded engine log path. It defaults to `~/.cuemap/server.log`, which is the file read by `cuemap logs`.
+
+### Server lifecycle
+
+The MCP server calls `EmbeddedCueMap.start()` as soon as Codex launches the plugin process, before any CueMap tool is invoked. It attaches to a compatible engine already listening at `CUEMAP_URL` or the configured port; otherwise it starts and owns a local engine automatically. `cuemap_init` does not start the server—it previews or applies a confirmed repository scope after the engine is ready. An engine owned by the MCP process is stopped gracefully when that process exits.
 
 ## Using with AI Agents
 
@@ -50,20 +56,64 @@ To use this MCP server with your AI assistant, add it to your assistant's MCP co
 
 ## Available Tools
 
-- **`cuemap_init`**: Autonomously initializes a CueMap project for a given local repository path. This triggers the Self-Learning Agent to instantly ingest the codebase so `cuemap_recall` can be used.
-  - `path` (string): Absolute path to the local repository.
-  - `projectName` (string, optional): The ID of the project to create. Defaults to the folder name of the path.
-
-- **`cuemap_add`**: Stores one natural-language memory in an explicit project. The project is created automatically if it does not exist.
+- **`cuemap_init_preview`**: Performs a read-only repository metadata scan and returns supported top-level folders/root files, counts, the stable repository project ID, and any existing saved scope. Present this preview to the user before ingestion.
+  - `path` (string): Absolute path to the repository root.
+  - `projectName` (string, optional): Project ID override. Defaults to the stable repository-scoped ID.
+  - `includedPaths` (string[], optional): Repository-relative files or folders to preview. Empty means all supported files allowed by ignore rules.
+  - `ignoredPatterns` (string[], optional): Additional gitignore-style exclusions.
+  - `ignoredExtensions` (string[], optional): Additional excluded extensions.
+
+- **`cuemap_init`**: Applies a user-confirmed repository ingestion scope, starts the initial scan, and keeps watching that scope for new, changed, deleted, newly ignored, or newly unignored supported files. It only reports verified completion after observing ingestion activity, reaching a terminal job phase, and completing intent annotation; an initial `idle` status with `0/0` writes is not considered complete.
+  - `path` (string): Absolute path to the repository root.
+  - `projectName` (string, optional): Project ID override. Defaults to the stable repository-scoped ID.
+  - `includedPaths` (string[], optional): User-approved repository-relative files or folders. Empty means all supported files allowed by ignore rules.
+  - `ignoredPatterns` (string[], optional): Additional gitignore-style exclusions.
+  - `ignoredExtensions` (string[], optional): Additional excluded extensions.
+  - `confirmed` (boolean): Must be true only after explicit user confirmation of the previewed scope.
+
+- **`cuemap_status`**: Returns project-scoped background ingestion progress plus derived monitoring fields. Poll it after `cuemap_init` until `verified_complete` is `true`.
+  - `project` (string, optional): Project ID override. Defaults to the stable repository-scoped ID.
+  - `active`: Whether the current phase is non-terminal or writes/intent annotations remain pending.
+  - `observed_activity`: Whether this MCP process has observed an active phase or positive write/intent counts for the project.
+  - `pending_writes`: Remaining writes based on the latest totals.
+  - `pending_intents`: Remaining memory intent annotations based on the latest totals.
+  - `verified_complete`: True only after activity has been observed, the project reaches `done` or `idle`, no work failed or remains pending, and `intent_ready` is not false.
+
+### Project inspection and memory lifecycle
+
+- **`cuemap_projects`**: List projects and their summary metadata.
+- **`cuemap_stats`**: Read repository-project statistics, or global engine statistics with `global: true`.
+- **`cuemap_memory_get`**: Read one memory by numeric `memory_id`.
+- **`cuemap_memory_reinforce`**: Reinforce one memory, optionally on explicit `cues`.
+- **`cuemap_memory_delete`**: Permanently delete one memory. Requires `confirmed: true` after explicit user confirmation.
+- **`cuemap_project_export`**: Export a cursor-paginated project page with configurable content, cue, and metadata inclusion.
+- **`cuemap_project_artifacts`**: Inspect CueBridge artifact metadata without reloading it.
+
+### Explicit ingestion
+
+- **`cuemap_ingest_url`**: Ingest one URL or recursively crawl it with `depth` and `same_domain_only` controls.
+- **`cuemap_ingest_content`**: Ingest supplied text with filename, source-key, metadata, structural-cue, segmentation, and optional one-vector-per-produced-chunk `embeddings`.
+- **`cuemap_ingest_file`**: Ingest one user-approved local file path.
+
+These tools are for explicit ingestion requests. Repository initialization continues to use the preview, confirmation, and watcher workflow above.
+
+### Alias and Lexicon administration
+
+- **`cuemap_alias_list`**, **`cuemap_alias_add`**, **`cuemap_alias_merge`**: Inspect and manage manual cue aliases. Merging requires `confirmed: true`.
+- **`cuemap_lexicon_inspect`**, **`cuemap_lexicon_graph`**, **`cuemap_lexicon_wire`**, **`cuemap_lexicon_delete`**: Inspect and administer Lexicon relationships. Deletion requires `confirmed: true`.
+- **`cuemap_add`**: Stores one natural-language memory. The project is created automatically if it does not exist.
   - `content` (string): Memory content to store.
-  - `project` (string): Project ID that will own the memory.
+  - `project` (string, optional): Project ID that will own the memory. Defaults to the current repository-scoped project.
   - `cues` (string[], optional): Explicit cues/tags to associate with the memory.
   - `metadata` (object, optional): JSON metadata to store with the memory.
   - `source_key` (string, optional): Stable source key for deterministic upsert/deduplication.
-  - `cuepacks` (string[], optional): CuePack names to apply during deterministic cue extraction.
+  - `event_time` (number, optional): Original event timestamp as Unix seconds. Defaults to ingestion time.
+  - `embedding` (number[], optional): Precomputed memory embedding.
   - `disable_temporal_chunking` (boolean, optional): Disable temporal chunking for this memory.
   - `async_ingest` (boolean, optional): Process ingestion in the background and return immediately.
 
+- **`cuemap_intent_classify`**: Classifies text with the engine's local intent model. Accepts `target: "query"` or `"memory"` and returns relative intent scores, recall/memory eligibility, confidence weight, and model/taxonomy versions. Scores are ranking signals, not calibrated probabilities.
+
 - **`cuemap_recall`**: Recalls context about a codebase from your CueMap integrated brain. Uses natural language and semantic search to find relevant information.
   - `query` (string): The natural language query to search for.
   - `limit` (number, optional): Maximum results to return (default: 10).
@@ -78,12 +128,13 @@ To use this MCP server with your AI assistant, add it to your assistant's MCP co
   - `trace_timing` (boolean, optional): Include v0.7 timing diagnostics.
   - `disable_salience_bias` (boolean, optional): Disable salience scoring bias.
   - `disable_alias_expansion` (boolean, optional): Disable lexicon synonym injection during querying (default: true).
-  - `cuepacks` (string[], optional): Cuepack names to apply during query-intent expansion.
   - `parent_fusion` (`off` | `auto` | `force`, optional): Chunk-parent fusion mode.
   - `ordered_reconstruction` (`off` | `auto` | `force`, optional): Ordered session reconstruction mode.
   - `evidence_coverage` (`off` | `auto` | `force`, optional): Multi-evidence coverage mode.
   - `disable_cuebridge_artifacts` (boolean, optional): Disable CueBridge artifact expansion.
   - `cuebridge_gap_limit` (number, optional): Maximum CueBridge gap expansions.
+  - `semantic_mode` (`lexical`, `semantic`, or `hybrid`, optional): Choose cue-only recall, vector candidate discovery, or local semantic reranking of lexical candidates. The engine default is `hybrid`.
+- `query_embedding` (number[], optional): Supply a precomputed query vector when the calling application owns the embedding provider.
 
 ## License
 

package/build/index.js

@@ -8,106 +8,233 @@ const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
 const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
 const zod_1 = require("zod");
 const cuemap_1 = __importDefault(require("cuemap"));
-const child_process_1 = require("child_process");
+const embedded_1 = require("cuemap/embedded");
+const node_buffer_1 = require("node:buffer");
+const node_fs_1 = require("node:fs");
 const path_1 = __importDefault(require("path"));
-const os_1 = __importDefault(require("os"));
-const fs_1 = __importDefault(require("fs"));
-let engineProcess = null;
+const crypto_1 = require("crypto");
+const child_process_1 = require("child_process");
+const job_status_js_1 = require("./job-status.js");
+let embeddedEngine = null;
 let CUEMAP_URL = process.env.CUEMAP_URL;
 let client;
+const observedJobActivity = new Map();
+function git(cwd, args) {
+    const result = (0, child_process_1.spawnSync)("git", args, { cwd, encoding: "utf8", timeout: 1_500 });
+    return result.status === 0 ? result.stdout.trim() : "";
+}
+function canonicalRemote(remote) {
+    return remote
+        .replace(/^[^@\s]+@([^:]+):/, "ssh://$1/")
+        .replace(/:\/\/[^/@]+@/, "://")
+        .replace(/\.git$/, "")
+        .replace(/\/+$/, "")
+        .toLowerCase();
+}
+function defaultProjectId(cwd) {
+    if (process.env.CUEMAP_PROJECT)
+        return process.env.CUEMAP_PROJECT;
+    const root = git(cwd, ["rev-parse", "--show-toplevel"]) || cwd;
+    const remote = canonicalRemote(git(root, ["remote", "get-url", "origin"]));
+    const identity = remote || root;
+    const slug = path_1.default.basename(root)
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "workspace";
+    const digest = (0, crypto_1.createHash)("sha256").update(identity).digest("hex").slice(0, 10);
+    return `repo-${slug.slice(0, 40)}-${digest}`.slice(0, 64);
+}
+const DEFAULT_PROJECT = defaultProjectId(process.cwd());
 const server = new mcp_js_1.McpServer({
     name: "cuemap-mcp",
-    version: "1.0.0",
+    version: "0.7.2",
 });
-function getCuemapBinaryPath() {
-    if (process.env.CUEMAP_BIN)
-        return process.env.CUEMAP_BIN;
-    // Check optional dependencies dynamically
-    try {
-        const platform = os_1.default.platform();
-        const arch = os_1.default.arch();
-        const pkgName = `@cuemap-dev/engine-${platform}-${arch}`;
-        const resolved = require.resolve(`${pkgName}/package.json`);
-        const binPath = path_1.default.join(path_1.default.dirname(resolved), "bin", "cuemap");
-        if (fs_1.default.existsSync(binPath))
-            return binPath;
-    }
-    catch (e) {
-        // Ignored
-    }
-    // Fallback: Check locally built binary (for development)
-    const localPath = path_1.default.resolve(__dirname, "../../rust_engine/target/release/cuemap");
-    if (fs_1.default.existsSync(localPath))
-        return localPath;
-    return null;
-}
 async function startEngine() {
-    if (CUEMAP_URL) {
-        console.error(`Using external CueMap engine at ${CUEMAP_URL}`);
-        return;
+    const configuredPort = process.env.CUEMAP_PORT
+        ? Number.parseInt(process.env.CUEMAP_PORT, 10)
+        : undefined;
+    if (configuredPort !== undefined && (!Number.isInteger(configuredPort) || configuredPort < 1 || configuredPort > 65535)) {
+        throw new Error("CUEMAP_PORT must be an integer between 1 and 65535");
     }
-    const binPath = getCuemapBinaryPath();
-    if (!binPath) {
-        console.error("Could not find cuemap binary. Please install the correct optional dependency, set CUEMAP_BIN, or set CUEMAP_URL to an existing instance.");
-        console.error("Falling back to expecting 'cuemap' in PATH.");
+    embeddedEngine = await embedded_1.EmbeddedCueMap.start({
+        url: CUEMAP_URL,
+        binPath: process.env.CUEMAP_BIN,
+        port: configuredPort,
+        requiredCapabilities: [
+            "repository_ingestion_scope_v1",
+            "semantic_retrieval_v1",
+            "chunk_embeddings_v1",
+            "intent_classification_v1",
+            "intent_job_status_v1",
+        ],
+        configPath: process.env.CUEMAP_CONFIG_PATH,
+        apiKey: process.env.CUEMAP_API_KEY,
+        logger: (message) => console.error(message),
+    });
+    CUEMAP_URL = embeddedEngine.url;
+}
+async function shutdown(signal) {
+    try {
+        await embeddedEngine?.stop();
     }
-    const execPath = binPath || "cuemap";
-    const port = process.env.CUEMAP_PORT || "8080";
-    CUEMAP_URL = `http://127.0.0.1:${port}`;
-    const args = ["start", "--port", port];
-    if (process.env.CUEMAP_CONFIG_PATH) {
-        args.push("--config", process.env.CUEMAP_CONFIG_PATH);
-        console.error(`Using custom config at ${process.env.CUEMAP_CONFIG_PATH}`);
+    finally {
+        process.exit(signal === "SIGINT" ? 130 : 143);
     }
-    console.error(`Starting Embedded CueMap Engine on port ${port}...`);
-    engineProcess = (0, child_process_1.spawn)(execPath, args, {
-        stdio: "ignore",
-        env: { ...process.env, CUEMAP_PORT: port }
-    });
-    engineProcess.on("error", (err) => {
-        console.error("Failed to start embedded engine:", err);
-    });
-    engineProcess.on("exit", (code) => {
-        console.error(`Embedded engine exited with code ${code}`);
-    });
-    process.on("SIGINT", () => {
-        if (engineProcess)
-            engineProcess.kill("SIGINT");
-        process.exit(0);
+}
+function projectClient(project) {
+    return new cuemap_1.default({
+        url: CUEMAP_URL,
+        apiKey: process.env.CUEMAP_API_KEY,
+        projectId: project || DEFAULT_PROJECT,
     });
-    process.on("SIGTERM", () => {
-        if (engineProcess)
-            engineProcess.kill("SIGTERM");
-        process.exit(0);
+}
+function jsonToolResult(value) {
+    return {
+        content: [{
+                type: "text",
+                text: JSON.stringify(value, null, 2),
+            }],
+    };
+}
+function confirmationRequired(action) {
+    return {
+        content: [{
+                type: "text",
+                text: `No changes were made because ${action} requires confirmed: true after explicit user confirmation.`,
+            }],
+    };
+}
+function toolError(toolName, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error executing ${toolName}`, error);
+    return {
+        content: [{
+                type: "text",
+                text: `Error executing ${toolName} tool: ${message || "Unknown error"}`,
+            }],
+        isError: true,
+    };
+}
+async function engineRequest(method, requestPath, body, project) {
+    if (!CUEMAP_URL)
+        throw new Error("CueMap engine URL is not available");
+    const response = await fetch(`${CUEMAP_URL}${requestPath}`, {
+        method,
+        headers: {
+            ...(body === undefined ? {} : { "content-type": "application/json" }),
+            ...(process.env.CUEMAP_API_KEY ? { "X-API-Key": process.env.CUEMAP_API_KEY } : {}),
+            ...(project ? { "X-Project-ID": project } : {}),
+        },
+        ...(body === undefined ? {} : { body: JSON.stringify(body) }),
     });
-    // Wait slightly to ensure startup
-    await new Promise(resolve => setTimeout(resolve, 2000));
+    if (!response.ok) {
+        const message = await response.text();
+        throw new Error(`CueMap returned HTTP ${response.status}: ${message}`);
+    }
+    return await response.json();
 }
 async function main() {
     await startEngine();
-    client = new cuemap_1.default({ url: CUEMAP_URL });
+    process.once("SIGINT", () => void shutdown("SIGINT"));
+    process.once("SIGTERM", () => void shutdown("SIGTERM"));
+    client = new cuemap_1.default({
+        url: CUEMAP_URL,
+        apiKey: process.env.CUEMAP_API_KEY,
+        projectId: DEFAULT_PROJECT,
+    });
+    server.registerTool("cuemap_init_preview", {
+        description: "Preview supported repository files without ingesting content. Call this before first-time repository initialization, present the grouped paths to the user, and ask them to confirm or adjust the selection before calling cuemap_init.",
+        inputSchema: zod_1.z.object({
+            path: zod_1.z.string().describe("Absolute path to the repository root."),
+            projectName: zod_1.z.string().optional().describe("Optional project ID. Defaults to the stable repository-scoped CueMap project ID."),
+            includedPaths: zod_1.z.array(zod_1.z.string()).optional().describe("Optional repository-relative files or folders to preview. Empty means every supported file allowed by ignore rules."),
+            ignoredPatterns: zod_1.z.array(zod_1.z.string()).optional().describe("Optional additional gitignore-style exclusion patterns."),
+            ignoredExtensions: zod_1.z.array(zod_1.z.string()).optional().describe("Optional additional excluded extensions without a leading dot."),
+        }),
+    }, async (args) => {
+        try {
+            const project = args.projectName || defaultProjectId(args.path);
+            const projects = await client.listProjects();
+            const projectIds = projects.map((item) => typeof item === "string" ? item : item.project_id);
+            let currentScope = null;
+            if (projectIds.includes(project)) {
+                try {
+                    currentScope = await engineRequest("GET", `/projects/${encodeURIComponent(project)}/watch-dir`);
+                }
+                catch {
+                    currentScope = null;
+                }
+            }
+            const preview = await engineRequest("POST", "/ingest/directory/preview", {
+                watch_dir: args.path,
+                included_paths: args.includedPaths,
+                ignored_patterns: args.ignoredPatterns,
+                ignored_extensions: args.ignoredExtensions,
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            project_id: project,
+                            current_scope: currentScope,
+                            selection_semantics: "included_paths are repository-relative files or folders; an empty list selects all supported files allowed by ignore rules",
+                            preview,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            console.error("Error previewing CueMap initialization", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error previewing repository ingestion: ${error?.message || "Unknown error"}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
     server.registerTool("cuemap_init", {
-        description: "Initialize a CueMap project for a given local repository path. This triggers the Self-Learning Agent to ingest the codebase. Call this if the user hasn't set up the project yet or if cuemap_recall returns empty.",
+        description: "Apply a user-confirmed repository ingestion scope and start CueMap's incremental filesystem watcher. Always call cuemap_init_preview first for a new repository and obtain explicit user confirmation before setting confirmed=true.",
         inputSchema: zod_1.z.object({
-            path: zod_1.z.string().describe("Absolute path to the local repository."),
-            projectName: zod_1.z.string().optional().describe("The ID of the project to create. Defaults to the folder name of the path.")
+            path: zod_1.z.string().describe("Absolute path to the repository root."),
+            projectName: zod_1.z.string().optional().describe("Optional project ID. Defaults to the stable repository-scoped CueMap project ID."),
+            includedPaths: zod_1.z.array(zod_1.z.string()).optional().describe("User-approved repository-relative files or folders. Empty means every supported file allowed by ignore rules."),
+            ignoredPatterns: zod_1.z.array(zod_1.z.string()).optional().describe("Additional gitignore-style exclusion patterns approved by the user."),
+            ignoredExtensions: zod_1.z.array(zod_1.z.string()).optional().describe("Additional excluded extensions without a leading dot."),
+            confirmed: zod_1.z.boolean().describe("Must be true only after the user explicitly confirms the previewed ingestion scope."),
         })
     }, async (args) => {
         try {
-            const pName = args.projectName || path_1.default.basename(args.path);
+            if (!args.confirmed) {
+                return {
+                    content: [{ type: "text", text: "No repository files were ingested because the proposed scope was not confirmed." }],
+                };
+            }
+            const pName = args.projectName || defaultProjectId(args.path);
             const projects = await client.listProjects();
             const projectIds = projects.map((p) => typeof p === 'string' ? p : p.project_id);
             if (!projectIds.includes(pName)) {
                 await client.createProject(pName);
             }
-            await client.setProjectWatchDir(pName, args.path);
+            await engineRequest("POST", `/projects/${encodeURIComponent(pName)}/watch-dir`, {
+                watch_dir: args.path,
+                included_paths: args.includedPaths,
+                ignored_patterns: args.ignoredPatterns,
+                ignored_extensions: args.ignoredExtensions,
+            });
             console.error(`Started ingestion for project ${pName} at ${args.path}`);
+            observedJobActivity.set(pName, false);
             // Polling for job completion
             let isComplete = false;
             let checks = 0;
+            let lastStatus = null;
             while (!isComplete && checks < 60) {
                 const status = await client.jobsStatus(pName);
-                if (status.phase === "idle") {
+                lastStatus = status;
+                const evaluation = (0, job_status_js_1.evaluateJobStatus)(status, observedJobActivity.get(pName));
+                observedJobActivity.set(pName, evaluation.observed_activity);
+                if (evaluation.verified_complete) {
                     isComplete = true;
                     break;
                 }
@@ -116,12 +243,18 @@ async function main() {
             }
             if (isComplete) {
                 return {
-                    content: [{ type: "text", text: `Successfully initialized and ingested project ${pName}. You can now use cuemap_recall.` }]
+                    content: [{
+                            type: "text",
+                            text: `Successfully initialized and ingested project ${pName}. CueMap observed ingestion activity, reached a terminal job phase, and completed memory intent annotation. The watcher will automatically ingest new or changed supported files within the approved scope. You can now use cuemap_recall.`,
+                        }]
                 };
             }
             else {
                 return {
-                    content: [{ type: "text", text: `Project ${pName} initialized, but ingestion is still actively running in the background. Partial results may be returned by cuemap_recall.` }]
+                    content: [{
+                            type: "text",
+                            text: `Project ${pName} initialized with the approved scope, but ingestion has not reached a verified terminal state. Last job status: ${JSON.stringify(lastStatus)}. Call cuemap_status periodically until verified_complete is true. The watcher is active and partial results may be returned by cuemap_recall.`,
+                        }]
                 };
             }
         }
@@ -134,34 +267,41 @@ async function main() {
         }
     });
     server.registerTool("cuemap_add", {
-        description: "Store a natural-language memory in an explicit CueMap project. Creates the project if it does not exist, then applies deterministic cue extraction plus any supplied cues and metadata.",
+        description: "Store a natural-language memory in CueMap. Uses the repository-scoped default project unless one is supplied, creates it when needed, and applies deterministic cue extraction plus any cues and metadata.",
         inputSchema: zod_1.z.object({
             content: zod_1.z.string().min(1).describe("The natural-language memory content to store."),
-            project: zod_1.z.string().min(1).describe("The project ID that will own the memory."),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to a stable ID derived from the current Git repository."),
             cues: zod_1.z.array(zod_1.z.string()).optional().describe("Optional explicit cues/tags to associate with the memory."),
             metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional().describe("Optional JSON metadata to store with the memory."),
             source_key: zod_1.z.string().optional().describe("Optional stable source key for deterministic upsert/deduplication."),
-            cuepacks: zod_1.z.array(zod_1.z.string()).optional().describe("Optional CuePack names to apply during deterministic cue extraction."),
+            event_time: zod_1.z.number().nonnegative().optional().describe("Optional original event timestamp as Unix seconds. Defaults to ingestion time."),
+            embedding: zod_1.z.array(zod_1.z.number()).nonempty().optional().describe("Optional precomputed memory embedding."),
             disable_temporal_chunking: zod_1.z.boolean().optional().describe("Disable temporal chunking for this memory. Default is false."),
             async_ingest: zod_1.z.boolean().optional().describe("Process ingestion in the background and return immediately. Default is false."),
         })
     }, async (args) => {
         try {
+            const project = args.project || DEFAULT_PROJECT;
             const projects = await client.listProjects();
             const projectIds = projects.map((p) => typeof p === "string" ? p : p.project_id);
-            if (!projectIds.includes(args.project)) {
-                await client.createProject(args.project);
+            if (!projectIds.includes(project)) {
+                await client.createProject(project);
             }
-            const projectClient = new cuemap_1.default({ url: CUEMAP_URL, projectId: args.project });
+            const projectClient = new cuemap_1.default({
+                url: CUEMAP_URL,
+                apiKey: process.env.CUEMAP_API_KEY,
+                projectId: project,
+            });
             const memoryId = await projectClient.add(args.content, args.cues || [], args.metadata, args.disable_temporal_chunking || false, {
                 sourceKey: args.source_key,
-                cuepacks: args.cuepacks,
+                eventTime: args.event_time,
+                embedding: args.embedding,
                 asyncIngest: args.async_ingest,
             });
             return {
                 content: [{
                         type: "text",
-                        text: `Stored memory ${memoryId} in CueMap project ${args.project}.`,
+                        text: `Stored memory ${memoryId} in CueMap project ${project}.`,
                     }],
             };
         }
@@ -176,8 +316,360 @@ async function main() {
             };
         }
     });
+    server.registerTool("cuemap_intent_classify", {
+        description: "Classify text with CueMap's local intent model and return recall/memory eligibility signals. Scores are ranking signals, not calibrated probabilities.",
+        inputSchema: zod_1.z.object({
+            text: zod_1.z.string().min(1),
+            target: zod_1.z.enum(["query", "memory"]).optional().describe("Classification target. Default is query."),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            return jsonToolResult(await projectClient(args.project).classifyIntent(args.text, args.target || "query"));
+        }
+        catch (error) {
+            return toolError("cuemap_intent_classify", error);
+        }
+    });
+    server.registerTool("cuemap_status", {
+        description: "Check CueMap background ingestion progress for a project. After cuemap_init, poll this tool until verified_complete is true. An initial idle status with 0/0 writes is not proof that ingestion completed.",
+        inputSchema: zod_1.z.object({
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the stable repository-scoped CueMap project ID."),
+        }),
+    }, async (args) => {
+        try {
+            const project = args.project || DEFAULT_PROJECT;
+            const status = await client.jobsStatus(project);
+            const evaluation = (0, job_status_js_1.evaluateJobStatus)(status, observedJobActivity.get(project));
+            observedJobActivity.set(project, evaluation.observed_activity);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            project_id: project,
+                            ...status,
+                            ...evaluation,
+                        }, null, 2),
+                    }],
+            };
+        }
+        catch (error) {
+            console.error("Error checking CueMap status", error);
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error executing cuemap_status tool: ${error?.message || "Unknown error"}`,
+                    }],
+                isError: true,
+            };
+        }
+    });
+    server.registerTool("cuemap_projects", {
+        description: "List CueMap projects and their available summary metadata.",
+        inputSchema: zod_1.z.object({}),
+    }, async () => {
+        try {
+            return jsonToolResult(await client.listProjects());
+        }
+        catch (error) {
+            return toolError("cuemap_projects", error);
+        }
+    });
+    server.registerTool("cuemap_stats", {
+        description: "Read CueMap statistics for the repository-scoped project or globally across the engine.",
+        inputSchema: zod_1.z.object({
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+            global: zod_1.z.boolean().optional().describe("Return global engine statistics instead of project statistics. Default is false."),
+        }),
+    }, async (args) => {
+        try {
+            if (args.global && args.project) {
+                throw new Error("project and global cannot be supplied together");
+            }
+            const project = args.global ? undefined : (args.project || DEFAULT_PROJECT);
+            return jsonToolResult(await engineRequest("GET", "/stats", undefined, project));
+        }
+        catch (error) {
+            return toolError("cuemap_stats", error);
+        }
+    });
+    server.registerTool("cuemap_memory_get", {
+        description: "Get one CueMap memory by numeric ID.",
+        inputSchema: zod_1.z.object({
+            memory_id: zod_1.z.number().int().nonnegative().max(4_294_967_295),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            const project = args.project || DEFAULT_PROJECT;
+            return jsonToolResult(await engineRequest("GET", `/memories/${args.memory_id}`, undefined, project));
+        }
+        catch (error) {
+            return toolError("cuemap_memory_get", error);
+        }
+    });
+    server.registerTool("cuemap_memory_reinforce", {
+        description: "Reinforce one CueMap memory, optionally along specific cue pathways.",
+        inputSchema: zod_1.z.object({
+            memory_id: zod_1.z.number().int().nonnegative().max(4_294_967_295),
+            cues: zod_1.z.array(zod_1.z.string().min(1)).optional(),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            const project = args.project || DEFAULT_PROJECT;
+            return jsonToolResult(await engineRequest("PATCH", `/memories/${args.memory_id}/reinforce`, { cues: args.cues || [] }, project));
+        }
+        catch (error) {
+            return toolError("cuemap_memory_reinforce", error);
+        }
+    });
+    server.registerTool("cuemap_memory_delete", {
+        description: "Permanently delete one CueMap memory. Set confirmed=true only after explicit user confirmation.",
+        inputSchema: zod_1.z.object({
+            memory_id: zod_1.z.number().int().nonnegative().max(4_294_967_295),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+            confirmed: zod_1.z.boolean().describe("Must be true only after the user explicitly confirms permanent deletion."),
+        }),
+    }, async (args) => {
+        if (!args.confirmed)
+            return confirmationRequired("memory deletion");
+        try {
+            const project = args.project || DEFAULT_PROJECT;
+            return jsonToolResult(await engineRequest("DELETE", `/memories/${args.memory_id}`, undefined, project));
+        }
+        catch (error) {
+            return toolError("cuemap_memory_delete", error);
+        }
+    });
+    server.registerTool("cuemap_ingest_url", {
+        description: "Explicitly ingest content from a URL, optionally crawling same-domain links. Use only when the user asks to ingest that URL.",
+        inputSchema: zod_1.z.object({
+            url: zod_1.z.string().url(),
+            depth: zod_1.z.number().int().nonnegative().max(10).optional().describe("Crawl depth. Zero ingests only the supplied page."),
+            same_domain_only: zod_1.z.boolean().optional().describe("Restrict recursive crawling to the starting domain. Default is true."),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            const result = await projectClient(args.project).ingestUrl(args.url, args.depth || 0, args.same_domain_only ?? true);
+            return jsonToolResult(result);
+        }
+        catch (error) {
+            return toolError("cuemap_ingest_url", error);
+        }
+    });
+    server.registerTool("cuemap_ingest_content", {
+        description: "Explicitly ingest supplied raw content into CueMap. Use only when the user asks to persist that content.",
+        inputSchema: zod_1.z.object({
+            content: zod_1.z.string().min(1),
+            filename: zod_1.z.string().min(1).optional().describe("Logical source filename used for type detection. Default is content.txt."),
+            source_key: zod_1.z.string().optional().describe("Stable source key for deterministic replacement or deduplication."),
+            metadata: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()).optional(),
+            structural_cues: zod_1.z.array(zod_1.z.string()).optional(),
+            embeddings: zod_1.z.array(zod_1.z.array(zod_1.z.number()).nonempty()).optional().describe("Optional one-vector-per-produced-chunk embeddings."),
+            segmenter: zod_1.z.enum(["sentence_window", "logical_block"]).optional(),
+            segment_window_size: zod_1.z.number().int().positive().optional(),
+            segment_overlap: zod_1.z.number().int().nonnegative().optional(),
+            segment_min_chunk_chars: zod_1.z.number().int().positive().optional(),
+            segment_max_chunk_chars: zod_1.z.number().int().positive().optional(),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            const result = await projectClient(args.project).ingestContent(args.content, args.filename || "content.txt", {
+                sourceKey: args.source_key,
+                metadata: args.metadata,
+                structuralCues: args.structural_cues,
+                embeddings: args.embeddings,
+                segmenter: args.segmenter,
+                segmentWindowSize: args.segment_window_size,
+                segmentOverlap: args.segment_overlap,
+                segmentMinChunkChars: args.segment_min_chunk_chars,
+                segmentMaxChunkChars: args.segment_max_chunk_chars,
+            });
+            return jsonToolResult(result);
+        }
+        catch (error) {
+            return toolError("cuemap_ingest_content", error);
+        }
+    });
+    server.registerTool("cuemap_ingest_file", {
+        description: "Explicitly ingest one local file into CueMap. Use only for a file the user has placed in scope and asked to ingest.",
+        inputSchema: zod_1.z.object({
+            path: zod_1.z.string().min(1).describe("Absolute or repository-relative path to the file."),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            const filePath = path_1.default.resolve(args.path);
+            if (!(0, node_fs_1.statSync)(filePath).isFile()) {
+                throw new Error(`Not a regular file: ${filePath}`);
+            }
+            const file = new node_buffer_1.File([(0, node_fs_1.readFileSync)(filePath)], path_1.default.basename(filePath), { type: "application/octet-stream" });
+            return jsonToolResult(await projectClient(args.project).ingestFile(file));
+        }
+        catch (error) {
+            return toolError("cuemap_ingest_file", error);
+        }
+    });
+    server.registerTool("cuemap_project_export", {
+        description: "Export a cursor-paginated page of memories from a CueMap project.",
+        inputSchema: zod_1.z.object({
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+            cursor: zod_1.z.union([zod_1.z.number().int().nonnegative(), zod_1.z.string().min(1)]).optional(),
+            limit: zod_1.z.number().int().positive().max(10_000).optional(),
+            include_content: zod_1.z.boolean().optional(),
+            include_cues: zod_1.z.boolean().optional(),
+            include_metadata: zod_1.z.boolean().optional(),
+        }),
+    }, async (args) => {
+        try {
+            const project = args.project || DEFAULT_PROJECT;
+            return jsonToolResult(await projectClient(project).exportProject(project, {
+                cursor: args.cursor,
+                limit: args.limit,
+                includeContent: args.include_content,
+                includeCues: args.include_cues,
+                includeMetadata: args.include_metadata,
+            }));
+        }
+        catch (error) {
+            return toolError("cuemap_project_export", error);
+        }
+    });
+    server.registerTool("cuemap_project_artifacts", {
+        description: "Inspect CueBridge artifact metadata for a CueMap project without reloading or mutating it.",
+        inputSchema: zod_1.z.object({
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            const project = args.project || DEFAULT_PROJECT;
+            return jsonToolResult(await projectClient(project).projectArtifacts(project));
+        }
+        catch (error) {
+            return toolError("cuemap_project_artifacts", error);
+        }
+    });
+    server.registerTool("cuemap_alias_list", {
+        description: "List manual cue aliases associated with one cue.",
+        inputSchema: zod_1.z.object({
+            cue: zod_1.z.string().min(1),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            return jsonToolResult(await projectClient(args.project).getAliases(args.cue));
+        }
+        catch (error) {
+            return toolError("cuemap_alias_list", error);
+        }
+    });
+    server.registerTool("cuemap_alias_add", {
+        description: "Add a manual weighted mapping from one cue to another.",
+        inputSchema: zod_1.z.object({
+            from: zod_1.z.string().min(1),
+            to: zod_1.z.string().min(1),
+            weight: zod_1.z.number().min(0).max(1).optional().describe("Association weight from 0 to 1. Default is 1."),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            const added = await projectClient(args.project).addAlias(args.from, args.to, args.weight ?? 1);
+            if (!added)
+                throw new Error("CueMap rejected the alias mapping");
+            return jsonToolResult({ added: true, from: args.from, to: args.to, weight: args.weight ?? 1 });
+        }
+        catch (error) {
+            return toolError("cuemap_alias_add", error);
+        }
+    });
+    server.registerTool("cuemap_alias_merge", {
+        description: "Merge multiple cues into one canonical cue. Set confirmed=true only after explicit user confirmation.",
+        inputSchema: zod_1.z.object({
+            cues: zod_1.z.array(zod_1.z.string().min(1)).min(2),
+            to: zod_1.z.string().min(1),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+            confirmed: zod_1.z.boolean().describe("Must be true only after the user explicitly confirms the merge."),
+        }),
+    }, async (args) => {
+        if (!args.confirmed)
+            return confirmationRequired("alias merging");
+        try {
+            const merged = await projectClient(args.project).mergeAliases(args.cues, args.to);
+            if (!merged)
+                throw new Error("CueMap rejected the alias merge");
+            return jsonToolResult({ merged: true, cues: args.cues, to: args.to });
+        }
+        catch (error) {
+            return toolError("cuemap_alias_merge", error);
+        }
+    });
+    server.registerTool("cuemap_lexicon_inspect", {
+        description: "Inspect one cue and its Lexicon relationships.",
+        inputSchema: zod_1.z.object({
+            cue: zod_1.z.string().min(1),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            return jsonToolResult(await projectClient(args.project).lexiconInspect(args.cue));
+        }
+        catch (error) {
+            return toolError("cuemap_lexicon_inspect", error);
+        }
+    });
+    server.registerTool("cuemap_lexicon_graph", {
+        description: "Read the current Lexicon graph for a project.",
+        inputSchema: zod_1.z.object({
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            return jsonToolResult(await projectClient(args.project).lexiconGraph());
+        }
+        catch (error) {
+            return toolError("cuemap_lexicon_graph", error);
+        }
+    });
+    server.registerTool("cuemap_lexicon_wire", {
+        description: "Manually wire a token to a canonical Lexicon cue.",
+        inputSchema: zod_1.z.object({
+            token: zod_1.z.string().min(1),
+            canonical: zod_1.z.string().min(1),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+        }),
+    }, async (args) => {
+        try {
+            return jsonToolResult(await projectClient(args.project).lexiconWire(args.token, args.canonical));
+        }
+        catch (error) {
+            return toolError("cuemap_lexicon_wire", error);
+        }
+    });
+    server.registerTool("cuemap_lexicon_delete", {
+        description: "Permanently delete one Lexicon entry. Set confirmed=true only after explicit user confirmation.",
+        inputSchema: zod_1.z.object({
+            entry_id: zod_1.z.union([zod_1.z.number().int().nonnegative(), zod_1.z.string().min(1)]),
+            project: zod_1.z.string().min(1).optional().describe("Optional project ID. Defaults to the repository-scoped project."),
+            confirmed: zod_1.z.boolean().describe("Must be true only after the user explicitly confirms permanent deletion."),
+        }),
+    }, async (args) => {
+        if (!args.confirmed)
+            return confirmationRequired("Lexicon entry deletion");
+        try {
+            const deleted = await projectClient(args.project).lexiconDelete(String(args.entry_id));
+            if (!deleted)
+                throw new Error("CueMap did not delete the Lexicon entry");
+            return jsonToolResult({ deleted: true, entry_id: args.entry_id });
+        }
+        catch (error) {
+            return toolError("cuemap_lexicon_delete", error);
+        }
+    });
     server.registerTool("cuemap_recall", {
-        description: "Recall context about a codebase from a CueMap integrated brain. Uses natural language and associative search to find relevant information.",
+        description: "Recall ranked context from CueMap using lexical, semantic, or hybrid query signals. Hybrid is the engine default and uses the configured local encoder to rerank lexical candidates.",
         inputSchema: zod_1.z.object({
             query: zod_1.z.string().describe("The natural language query to search the codebase memory for."),
             limit: zod_1.z.number().optional().describe("Optional limit on the number of results to return. Default is 10."),
@@ -192,7 +684,6 @@ async function main() {
             trace_timing: zod_1.z.boolean().optional().describe("Include v0.7 timing diagnostics in the response. Default is false."),
             disable_salience_bias: zod_1.z.boolean().optional().describe("Disable salience bias scoring. Default is false."),
             disable_alias_expansion: zod_1.z.boolean().optional().describe("Disable alias expansion during querying. Default is true."),
-            cuepacks: zod_1.z.array(zod_1.z.string()).optional().describe("Optional cuepack names to apply during query-intent expansion."),
             parent_fusion: zod_1.z.enum(["off", "auto", "force"]).optional().describe("Parent fusion mode for chunk-parent reconstruction. Default is off."),
             parent_fusion_limit: zod_1.z.number().optional().describe("Candidate limit for parent fusion. Default is 80."),
             parent_fusion_min_chunks: zod_1.z.number().optional().describe("Minimum sibling chunks required for parent fusion. Default is 2."),
@@ -206,10 +697,12 @@ async function main() {
             evidence_coverage_max_sessions: zod_1.z.number().optional().describe("Maximum sessions considered for evidence coverage. Default is 3."),
             disable_cuebridge_artifacts: zod_1.z.boolean().optional().describe("Disable CueBridge artifact expansion. Default is false."),
             cuebridge_gap_limit: zod_1.z.number().optional().describe("Maximum CueBridge gap expansions. Default is 6."),
+            semantic_mode: zod_1.z.enum(["lexical", "semantic", "hybrid"]).optional().describe("Query signal mode. lexical uses cue recall only, semantic uses vector candidate discovery, and hybrid reranks lexical candidates. Default is hybrid."),
+            query_embedding: zod_1.z.array(zod_1.z.number()).optional().describe("Optional precomputed query vector. Use this when the application owns the embedding provider."),
         }),
     }, async (args) => {
         try {
-            const { query, limit = 10, projects, cues, query_time, depth = 1, expansion_depth = 1, auto_reinforce = false, min_intersection, explain = false, trace_timing = false, disable_salience_bias = false, disable_alias_expansion = true, cuepacks, parent_fusion = "off", parent_fusion_limit = 80, parent_fusion_min_chunks = 2, ordered_reconstruction = "off", ordered_reconstruction_limit = 80, ordered_session_scan_limit = 4096, ordered_max_sessions = 3, evidence_coverage = "off", evidence_coverage_limit = 100, evidence_coverage_session_scan_limit = 4096, evidence_coverage_max_sessions = 3, disable_cuebridge_artifacts = false, cuebridge_gap_limit = 6 } = args;
+            const { query, limit = 10, projects, cues, query_time, depth = 1, expansion_depth = 1, auto_reinforce = false, min_intersection, explain = false, trace_timing = false, disable_salience_bias = false, disable_alias_expansion = true, parent_fusion = "off", parent_fusion_limit = 80, parent_fusion_min_chunks = 2, ordered_reconstruction = "off", ordered_reconstruction_limit = 80, ordered_session_scan_limit = 4096, ordered_max_sessions = 3, evidence_coverage = "off", evidence_coverage_limit = 100, evidence_coverage_session_scan_limit = 4096, evidence_coverage_max_sessions = 3, disable_cuebridge_artifacts = false, cuebridge_gap_limit = 6, semantic_mode = "hybrid", query_embedding } = args;
             const results = await client.recall({
                 query_text: query,
                 cues,
@@ -224,7 +717,6 @@ async function main() {
                 trace_timing,
                 disable_salience_bias,
                 disable_alias_expansion,
-                cuepacks,
                 parent_fusion,
                 parent_fusion_limit,
                 parent_fusion_min_chunks,
@@ -238,6 +730,8 @@ async function main() {
                 evidence_coverage_max_sessions,
                 disable_cuebridge_artifacts,
                 cuebridge_gap_limit,
+                semantic_mode,
+                query_embedding,
             });
             let items = [];
             if (results.results && Array.isArray(results.results)) {
@@ -262,7 +756,7 @@ async function main() {
                     ],
                 };
             }
-            let formattedText = `CueMap found ${items.length} relevant results:\n\n`;
+            let formattedText = `CueMap found ${items.length} relevant memories:\n\n`;
             items.forEach((r, i) => {
                 const scoreStr = r.score !== undefined ? ` (Score: ${Number(r.score).toFixed(2)})` : '';
                 formattedText += `### Result ${i + 1}${scoreStr}\n`;
@@ -303,7 +797,7 @@ async function main() {
     });
     const transport = new stdio_js_1.StdioServerTransport();
     await server.connect(transport);
-    console.error("CueMap MCP server running on stdio");
+    console.error(`CueMap MCP server running on stdio (default project: ${DEFAULT_PROJECT})`);
 }
 main().catch((error) => {
     console.error("Server error:", error);

package/build/job-status.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateJobStatus = evaluateJobStatus;
+const TERMINAL_PHASES = new Set(["done", "idle"]);
+function evaluateJobStatus(status, previouslyObservedActivity = false) {
+    const phase = String(status.phase || "").toLowerCase();
+    const writesCompleted = Number.isFinite(status.writes_completed)
+        ? Math.max(0, status.writes_completed)
+        : 0;
+    const writesTotal = Number.isFinite(status.writes_total)
+        ? Math.max(0, status.writes_total)
+        : 0;
+    const intentCompleted = Number.isFinite(status.intent_completed)
+        ? Math.max(0, status.intent_completed || 0)
+        : 0;
+    const intentTotal = Number.isFinite(status.intent_total)
+        ? Math.max(0, status.intent_total || 0)
+        : 0;
+    const intentFailed = Number.isFinite(status.intent_failed)
+        ? Math.max(0, status.intent_failed || 0)
+        : 0;
+    const pendingWrites = Math.max(0, writesTotal - writesCompleted);
+    const pendingIntents = Math.max(0, intentTotal - intentCompleted - intentFailed);
+    const active = !TERMINAL_PHASES.has(phase) || pendingWrites > 0 || pendingIntents > 0;
+    const observedActivity = previouslyObservedActivity
+        || active
+        || writesCompleted > 0
+        || writesTotal > 0
+        || intentCompleted > 0
+        || intentTotal > 0
+        || intentFailed > 0;
+    return {
+        active,
+        observed_activity: observedActivity,
+        pending_writes: pendingWrites,
+        pending_intents: pendingIntents,
+        verified_complete: observedActivity
+            && TERMINAL_PHASES.has(phase)
+            && pendingWrites === 0
+            && pendingIntents === 0
+            && intentFailed === 0
+            && status.intent_ready !== false,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cuemap-mcp",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "MCP server for CueMap",
   "main": "build/index.js",
   "bin": {
@@ -13,6 +13,9 @@
   ],
   "scripts": {
     "build": "tsc",
+    "test": "npm run build && node --test test/*.test.cjs",
+    "test:e2e": "CUEMAP_E2E=1 node --test test/*.test.cjs",
+    "test:pack": "node scripts/verify-packed-install.cjs",
     "start": "node build/index.js",
     "dev": "tsc --watch"
   },
@@ -32,7 +35,7 @@
   "type": "commonjs",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.27.1",
-    "cuemap": "^0.7.0",
+    "cuemap": "^0.7.2",
     "zod": "^4.3.6"
   },
   "devDependencies": {
@@ -40,8 +43,8 @@
     "typescript": "^5.9.3"
   },
   "optionalDependencies": {
-    "@cuemap-dev/engine-darwin-arm64": "^0.7.0",
-    "@cuemap-dev/engine-darwin-x64": "^0.7.0",
-    "@cuemap-dev/engine-linux-x64": "^0.7.0"
+    "@cuemap-dev/engine-darwin-arm64": "^0.7.2",
+    "@cuemap-dev/engine-darwin-x64": "^0.7.2",
+    "@cuemap-dev/engine-linux-x64": "^0.7.2"
   }
 }