@adrive/mcp-server 0.4.0 → 1.1.0

package/README.md

@@ -1,6 +1,6 @@
 # @adrive/mcp-server
 
-MCP server for **AgentDrive** — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph. Files, semantic search, run logging, and cross-platform memory.
+MCP server for **AgentDrive** — the cross-agent artifact workspace with provenance and portable storage across Claude Code, Codex, Cursor, and LangGraph. Files, semantic recall, run logging, and cross-platform attribution.
 
 Drop this server into any MCP-compatible client and your agents get a shared filesystem with provenance, semantic search across artifacts written by other agents, and per-run audit. Memory is a feature of the workspace, not the headline.
 
@@ -16,37 +16,28 @@ npx @adrive/mcp-server
 
 | Variable | Required | Default | Notes |
 |---|---|---|---|
-| `AGENTDRIVE_API_KEY` | yes | — | API key from `drive init` or the dashboard. |
+| `AGENTDRIVE_API_KEY` | no | key saved by `adrive auth login` | Falls back to `~/.config/agentdrive/config.json`, so client configs never need the key inline. |
 | `AGENTDRIVE_API_URL` | no | `https://app.agentdrive.sh` | Override for self-host or staging. |
-| `AGENTDRIVE_AGENT_PLATFORM` | no | `claude-code` | Identifies which host is calling. Valid: `claude-code | codex | cursor | langgraph | crewai | autogen | hermes | openclaw | unknown`. Unknown values downgrade to `unknown` server-side. |
+| `AGENTDRIVE_AGENT_PLATFORM` | no | `unknown` | Identifies which host is calling. Valid: `claude-code | codex | opencode | gemini-cli | cursor | langgraph | crewai | autogen | hermes | openclaw | unknown`. Unknown values downgrade to `unknown` server-side. |
 | `AGENTDRIVE_AGENT_ROLE` | no | (empty) | Free-form role label (`planner`, `reviewer`, etc.). Stamped on every request for provenance. |
 
+The server derives the current project from its working directory (git remote, else repo path), which scopes `drive_sessions` and `drive_resume`.
+
 ## Client configuration
 
-### Claude Code (`~/.claude/mcp-servers.json` or `claude_desktop_config.json`)
+`curl -fsSL https://app.agentdrive.sh/install | sh` runs `adrive init`, which wires every detected harness. For Claude Code, install the plugin instead: `/plugin marketplace add Rakesh1002/agentdrive` then `/plugin install agentdrive@agentdrive`.
 
-```json
-{
-  "mcpServers": {
-    "agentdrive": {
-      "command": "npx",
-      "args": ["-y", "@adrive/mcp-server"],
-      "env": {
-        "AGENTDRIVE_API_KEY": "agentdrive_live_..."
-      }
-    }
-  }
-}
-```
+Manual entries, for reference:
 
-### Codex CLI (`~/.codex/config.toml` or equivalent)
+### Codex CLI (`~/.codex/config.toml`)
 
 ```toml
-[[mcp_servers]]
-name = "agentdrive"
+[mcp_servers.agentdrive]
 command = "npx"
 args = ["-y", "@adrive/mcp-server"]
-env = { AGENTDRIVE_API_KEY = "agentdrive_live_...", AGENTDRIVE_AGENT_PLATFORM = "codex" }
+
+[mcp_servers.agentdrive.env]
+AGENTDRIVE_AGENT_PLATFORM = "codex"
 ```
 
 ### Cursor (`~/.cursor/mcp.json`)
@@ -57,16 +48,13 @@ env = { AGENTDRIVE_API_KEY = "agentdrive_live_...", AGENTDRIVE_AGENT_PLATFORM =
     "agentdrive": {
       "command": "npx",
       "args": ["-y", "@adrive/mcp-server"],
-      "env": {
-        "AGENTDRIVE_API_KEY": "agentdrive_live_...",
-        "AGENTDRIVE_AGENT_PLATFORM": "cursor"
-      }
+      "env": { "AGENTDRIVE_AGENT_PLATFORM": "cursor" }
     }
   }
 }
 ```
 
-## Tools (16)
+## Tools (22)
 
 **Files**
 - `drive_write` — create or update a file with versioning
@@ -83,6 +71,10 @@ env = { AGENTDRIVE_API_KEY = "agentdrive_live_...", AGENTDRIVE_AGENT_PLATFORM =
 - `drive_activity` — workspace event feed
 - `drive_versions` — file version history
 
+**Sessions**
+- `drive_sessions` — recent sessions in this project from every harness
+- `drive_resume` — load a prior session's handoff (defaults to the latest from another harness)
+
 **Search and memory**
 - `drive_search` — semantic search across artifacts
 - `drive_recall` — recall facts and preferences (narrows to extracted facts in a future release)

package/dist/api-client.d.ts

@@ -3,6 +3,8 @@ export interface ApiClientConfig {
     apiKey: string;
     agentPlatform?: string;
     agentRole?: string;
+    project?: string;
+    fetchImpl?: (input: string, init?: RequestInit) => Promise<Response>;
 }
 export interface PagedResponse<T> {
     items: T[];
@@ -38,7 +40,6 @@ export interface ContextRequestBody {
     task: string;
     workspace_id?: string;
     limit?: number;
-    include_facts?: boolean;
 }
 export interface ContextArtifact extends SearchHit {
 }
@@ -52,11 +53,35 @@ export interface RunRequestBody {
     duration_ms?: number;
     metadata?: Record<string, unknown>;
 }
+export interface AgentRunRecord {
+    run_id: string;
+    org_id: string;
+    workspace_id?: string;
+    agent_id: string;
+    agent_platform: string;
+    agent_role?: string;
+    task: string;
+    artifacts_referenced: string[];
+    artifacts_produced: string[];
+    duration_ms?: number;
+    status: RunStatus;
+    metadata: Record<string, unknown>;
+    created_at: number;
+    updated_at?: number;
+}
+export interface ListRunsQuery {
+    project: string;
+    platform?: string;
+    limit?: number;
+    cursor?: string;
+}
 export declare class ApiClient {
+    readonly project?: string;
+    readonly agentPlatform: string;
     private baseUrl;
     private apiKey;
-    private agentPlatform;
     private agentRole;
+    private fetchImpl;
     constructor(config: ApiClientConfig);
     private headers;
     rawFetch(path: string, init: RequestInit): Promise<Response>;
@@ -82,6 +107,13 @@ export declare class ApiClient {
         version: number;
         updated_at: string;
     }>;
+    readFileByPath(workspaceId: string, path: string): Promise<{
+        id: string;
+        path: string;
+        content: string;
+        version: number;
+        updated_at: string;
+    }>;
     listFilesPage(workspaceId: string, prefix: string | undefined, cursor: string | null): Promise<PagedResponse<{
         id: string;
         path: string;
@@ -233,6 +265,8 @@ export declare class ApiClient {
         run_id: string;
         created_at: number;
     }>;
+    listRuns(query: ListRunsQuery): Promise<PagedResponse<AgentRunRecord>>;
+    getRun(runId: string): Promise<AgentRunRecord>;
     sandboxClone(workspaceId: string, body: {
         url: string;
         branch?: string;

package/dist/api-client.js

@@ -12,15 +12,19 @@ export async function listAllPages(fetchPage, maxPages = 10) {
     return all;
 }
 export class ApiClient {
+    project;
+    agentPlatform;
     baseUrl;
     apiKey;
-    agentPlatform;
     agentRole;
+    fetchImpl;
     constructor(config) {
         this.baseUrl = config.baseUrl.replace(/\/$/, '');
         this.apiKey = config.apiKey;
         this.agentPlatform = config.agentPlatform ?? 'claude-code';
         this.agentRole = config.agentRole ?? '';
+        this.project = config.project;
+        this.fetchImpl = config.fetchImpl ?? ((input, init) => fetch(input, init));
     }
     headers() {
         return {
@@ -32,7 +36,7 @@ export class ApiClient {
     }
     async rawFetch(path, init) {
         const url = `${this.baseUrl}/v1${path}`;
-        return fetch(url, {
+        return this.fetchImpl(url, {
             ...init,
             headers: { ...this.headers(), ...init.headers },
         });
@@ -68,6 +72,13 @@ export class ApiClient {
     async readFile(workspaceId, fileId) {
         return this.request('GET', `/workspaces/${workspaceId}/files/${fileId}?content=true`);
     }
+    async readFileByPath(workspaceId, path) {
+        const page = await this.listFilesPage(workspaceId, path, null);
+        const match = page.items.find((f) => f.path === path);
+        if (!match)
+            throw new Error(`File not found: ${path}`);
+        return this.readFile(workspaceId, match.id);
+    }
     async listFilesPage(workspaceId, prefix, cursor) {
         const params = new URLSearchParams();
         if (prefix)
@@ -195,6 +206,19 @@ export class ApiClient {
     async logRun(body) {
         return this.request('POST', '/runs', body);
     }
+    async listRuns(query) {
+        const params = new URLSearchParams({ project: query.project });
+        if (query.platform)
+            params.set('platform', query.platform);
+        if (query.limit)
+            params.set('limit', String(query.limit));
+        if (query.cursor)
+            params.set('cursor', query.cursor);
+        return this.requestPage('GET', `/runs?${params.toString()}`);
+    }
+    async getRun(runId) {
+        return this.request('GET', `/runs/${encodeURIComponent(runId)}`);
+    }
     // --- Sandbox (Wave 5 Stream D) ---
     async sandboxClone(workspaceId, body) {
         return this.request('POST', `/workspaces/${workspaceId}/sandbox/clone`, body);

package/dist/index.js

@@ -1,33 +1,32 @@
 #!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { ApiClient } from './api-client.js';
-import { driveWriteSchema, driveWrite } from './tools/drive-write.js';
-import { driveReadSchema, driveRead } from './tools/drive-read.js';
-import { driveListSchema, driveList } from './tools/drive-list.js';
-import { driveShareSchema, driveShare } from './tools/drive-share.js';
-import { driveCommentSchema, driveComment } from './tools/drive-comment.js';
-import { driveFeedbackSchema, driveFeedback } from './tools/drive-feedback.js';
-import { driveActivitySchema, driveActivity } from './tools/drive-activity.js';
-import { driveInviteSchema, driveInvite } from './tools/drive-invite.js';
-import { driveRolesSchema, driveRoles } from './tools/drive-roles.js';
-import { driveOrgSchema, driveOrg } from './tools/drive-org.js';
-import { driveDeleteSchema, driveDelete } from './tools/drive-delete.js';
-import { driveVersionsSchema, driveVersions } from './tools/drive-versions.js';
-import { driveSearchSchema, driveSearch } from './tools/drive-search.js';
-import { driveRecallSchema, driveRecall } from './tools/drive-recall.js';
-import { driveLogRunSchema, driveLogRun } from './tools/drive-log-run.js';
-import { driveContextSchema, driveContext } from './tools/drive-context.js';
-import { driveSandboxCloneSchema, driveSandboxClone } from './tools/drive-sandbox-clone.js';
-import { driveSandboxExecSchema, driveSandboxExec } from './tools/drive-sandbox-exec.js';
-import { driveSandboxReadSchema, driveSandboxRead } from './tools/drive-sandbox-read.js';
-import { driveSandboxCommitSchema, driveSandboxCommit } from './tools/drive-sandbox-commit.js';
-const BASE_URL = process.env.AGENTDRIVE_API_URL || 'https://app.agentdrive.sh';
-const API_KEY = process.env.AGENTDRIVE_API_KEY;
-const AGENT_PLATFORM = process.env.AGENTDRIVE_AGENT_PLATFORM || 'claude-code';
+import { ApiClient, TOOLS, SERVER_INSTRUCTIONS } from './registry.js';
+import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { projectKeyFor, scopeProjectKey } from './project.js';
+const require = createRequire(import.meta.url);
+const pkg = require('../package.json');
+function readCliConfig() {
+    const xdg = process.env.XDG_CONFIG_HOME;
+    const base = xdg && xdg.length > 0 ? xdg : join(homedir(), '.config');
+    try {
+        return JSON.parse(readFileSync(join(base, 'agentdrive', 'config.json'), 'utf8'));
+    }
+    catch {
+        return {};
+    }
+}
+const fileConfig = readCliConfig();
+const cliConfig = process.env.AGENTDRIVE_API_KEY ? {} : fileConfig;
+const BASE_URL = process.env.AGENTDRIVE_API_URL || cliConfig.api_url || 'https://app.agentdrive.sh';
+const API_KEY = process.env.AGENTDRIVE_API_KEY || cliConfig.api_key;
+const AGENT_PLATFORM = process.env.AGENTDRIVE_AGENT_PLATFORM || 'unknown';
 const AGENT_ROLE = process.env.AGENTDRIVE_AGENT_ROLE || '';
 if (!API_KEY) {
-    console.error('AGENTDRIVE_API_KEY environment variable is required');
+    console.error('No AgentDrive API key found. Set AGENTDRIVE_API_KEY or run `adrive auth login`.');
     process.exit(1);
 }
 const client = new ApiClient({
@@ -35,32 +34,18 @@ const client = new ApiClient({
     apiKey: API_KEY,
     agentPlatform: AGENT_PLATFORM,
     agentRole: AGENT_ROLE,
+    project: scopeProjectKey(projectKeyFor(process.cwd()), !!fileConfig.preferences?.private_workspace),
 });
 const server = new McpServer({
     name: 'agentdrive',
-    version: '0.4.0',
+    version: pkg.version,
     description: 'AgentDrive — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph. Files, semantic search, run logging, cross-platform memory, and per-workspace Linux sandbox with git worktree.',
+}, {
+    instructions: SERVER_INSTRUCTIONS,
 });
-server.tool('drive_write', 'Write a markdown file to a workspace. Creates or updates the file with automatic versioning.', driveWriteSchema, (args) => driveWrite(client, args));
-server.tool('drive_read', 'Read a file\'s content from a workspace.', driveReadSchema, (args) => driveRead(client, args));
-server.tool('drive_list', 'List files in a workspace, optionally filtered by path prefix.', driveListSchema, (args) => driveList(client, args));
-server.tool('drive_share', 'Generate a share link for a workspace or specific file. Optionally email-gate the link so only a specific person can access it. Humans open this link to view, comment, or edit files.', driveShareSchema, (args) => driveShare(client, args));
-server.tool('drive_comment', 'Add a comment to a file.', driveCommentSchema, (args) => driveComment(client, args));
-server.tool('drive_feedback', 'Read human comments on a file. Use this to check if humans have left feedback.', driveFeedbackSchema, (args) => driveFeedback(client, args));
-server.tool('drive_activity', 'Get recent activity in a workspace (file writes, comments, shares).', driveActivitySchema, (args) => driveActivity(client, args));
-server.tool('drive_invite', 'Invite a human to your organization by email. They will receive a verification code to join.', driveInviteSchema, (args) => driveInvite(client, args));
-server.tool('drive_roles', 'Manage per-workspace role delegation. Assign, list, or remove access for specific emails (view/comment/edit).', driveRolesSchema, (args) => driveRoles(client, args));
-server.tool('drive_org', 'View your organization details: agents, members, plan, and usage.', driveOrgSchema, (args) => driveOrg(client, args));
-server.tool('drive_delete', 'Delete a file from a workspace.', driveDeleteSchema, (args) => driveDelete(client, args));
-server.tool('drive_versions', 'View version history for a file in a workspace.', driveVersionsSchema, (args) => driveVersions(client, args));
-server.tool('drive_search', "Semantic search across your org's artifacts in AgentDrive. Returns the top-N most relevant files. Use this BEFORE writing similar artifacts to avoid duplication and surface prior context.", driveSearchSchema, (args) => driveSearch(client, args));
-server.tool('drive_recall', 'Recall persistent facts and preferences your agents have written. In v1 this returns semantic search results across artifacts; v1.5 will narrow to auto-extracted facts (preferences, decisions, key entities).', driveRecallSchema, (args) => driveRecall(client, args));
-server.tool('drive_log_run', "Log an agent run to AgentDrive's provenance store. Captures task, status, referenced/produced artifacts, and cross-platform identity (which agent on which tool). Used for retrospective context retrieval and team-wide audit.", driveLogRunSchema, (args) => driveLogRun(client, args));
-server.tool('drive_context', 'Auto-pull the most relevant artifacts from prior agent sessions for the task you are about to do. Combines semantic relevance with recency. Call this at the START of any non-trivial task to ground the agent in prior context — replaces manual copy-paste of artifacts between sessions.', driveContextSchema, (args) => driveContext(client, args));
-server.tool('drive_sandbox_clone', 'Clone a git repo into a per-workspace Linux sandbox. The sandbox persists across MCP sessions for the workspace. Use this to set up a real dev environment your other agents can also drive.', driveSandboxCloneSchema, (args) => driveSandboxClone(client, args));
-server.tool('drive_sandbox_exec', 'Run a shell command inside the per-workspace Linux sandbox. Captures stdout/stderr (64KB cap), exit code, and duration. Use for `npm install`, running tests, file ops — any real dev workflow.', driveSandboxExecSchema, (args) => driveSandboxExec(client, args));
-server.tool('drive_sandbox_read', 'Read a file from the per-workspace sandbox filesystem (e.g., generated build artifacts, test output, log files).', driveSandboxReadSchema, (args) => driveSandboxRead(client, args));
-server.tool('drive_sandbox_commit', 'Stage + commit the current sandbox worktree. The commit surfaces as an AgentDrive artifact at commits/<sha>.json with cross-agent provenance — other agents on other platforms can see who shipped what.', driveSandboxCommitSchema, (args) => driveSandboxCommit(client, args));
+for (const tool of TOOLS) {
+    server.tool(tool.name, tool.description, tool.schema, (args) => tool.handler(client, args));
+}
 async function main() {
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/dist/project.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizeRemote(url: string): string | null;
+export declare function projectKeyFor(cwd: string): string;
+export declare function scopeProjectKey(key: string, privateWorkspace: boolean): string;

package/dist/project.js

@@ -0,0 +1,69 @@
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { basename } from 'node:path';
+function git(cwd, args) {
+    try {
+        const out = execFileSync('git', ['-C', cwd, ...args], {
+            encoding: 'utf8',
+            timeout: 1000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+function sha8(value) {
+    return createHash('sha256').update(value).digest('hex').slice(0, 8);
+}
+function slug(value) {
+    return value.toLowerCase().replace(/[^a-z0-9._-]/g, '-');
+}
+export function normalizeRemote(url) {
+    const trimmed = url.trim();
+    let host;
+    let path;
+    const scp = /^(?:[^@/]+@)?([^:/]+):(?!\/\/)(.+)$/.exec(trimmed);
+    if (/^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed)) {
+        let parsed;
+        try {
+            parsed = new URL(trimmed);
+        }
+        catch {
+            return null;
+        }
+        host = parsed.hostname;
+        path = parsed.pathname;
+    }
+    else if (scp) {
+        host = scp[1];
+        path = scp[2];
+    }
+    else {
+        return null;
+    }
+    const segments = path
+        .replace(/\.git\/?$/, '')
+        .split('/')
+        .filter(Boolean)
+        .map(slug);
+    if (!host || segments.length === 0)
+        return null;
+    return [slug(host), ...segments].join('__');
+}
+export function projectKeyFor(cwd) {
+    const remote = git(cwd, ['config', '--get', 'remote.origin.url']);
+    const normalized = remote ? normalizeRemote(remote) : null;
+    if (normalized)
+        return normalized.slice(0, 200);
+    const toplevel = git(cwd, ['rev-parse', '--show-toplevel']);
+    if (toplevel)
+        return `${slug(basename(toplevel)).slice(0, 150)}-${sha8(toplevel)}`;
+    return `local__${slug(basename(cwd)).slice(0, 150)}-${sha8(cwd)}`;
+}
+// A private workspace must not leak repo names through storage paths or the
+// project index, so the key is replaced by a stable hash of itself.
+export function scopeProjectKey(key, privateWorkspace) {
+    return privateWorkspace ? `p-${createHash('sha256').update(key).digest('hex').slice(0, 16)}` : key;
+}

package/dist/registry.d.ts

@@ -0,0 +1,20 @@
+import type { z } from 'zod';
+import type { ApiClient } from './api-client.js';
+export interface ToolResult {
+    [x: string]: unknown;
+    content: Array<{
+        type: 'text';
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export interface ToolDef {
+    name: string;
+    description: string;
+    schema: z.ZodRawShape;
+    handler: (client: ApiClient, args: any) => Promise<ToolResult>;
+}
+export declare const SERVER_INSTRUCTIONS = "AgentDrive \u2014 cross-agent artifact workspace with provenance for multi-agent workflows.\n\nReach for these tools without waiting to be asked:\n\n- **Session start:** call `drive_context` with a short summary of the\n  current task. Returns the most relevant artifacts and last_run\n  summaries from prior agents' work in the same workspace, each with\n  an `attribution` block explaining *why* it was surfaced.\n- **Continuing earlier work:** if the user is picking up where a prior\n  session left off (or a SessionStart note mentions prior sessions),\n  call `drive_sessions` to list this project's recent sessions across\n  harnesses, then `drive_resume` to load one's handoff brief.\n- **Cross-agent recall:** call `drive_search` (semantic) when the\n  user asks \"what did Codex / Cursor / the last session do?\"\n- **Saving work:** call `drive_write` for any artifact worth keeping\n  so the next agent in the chain can read it back.\n- **Provenance:** call `drive_log_run` at the end of meaningful\n  work so the cross-agent timeline stays accurate.\n\nPrivacy: if the user has Private Workspace on, written content is\nencrypted client-side; the AgentDrive server only stores ciphertext.";
+export declare const TOOLS: ToolDef[];
+export { ApiClient } from './api-client.js';
+export type { ApiClientConfig } from './api-client.js';

package/dist/registry.js

@@ -0,0 +1,73 @@
+import { driveWriteSchema, driveWrite } from './tools/drive-write.js';
+import { driveReadSchema, driveRead } from './tools/drive-read.js';
+import { driveListSchema, driveList } from './tools/drive-list.js';
+import { driveShareSchema, driveShare } from './tools/drive-share.js';
+import { driveCommentSchema, driveComment } from './tools/drive-comment.js';
+import { driveFeedbackSchema, driveFeedback } from './tools/drive-feedback.js';
+import { driveActivitySchema, driveActivity } from './tools/drive-activity.js';
+import { driveInviteSchema, driveInvite } from './tools/drive-invite.js';
+import { driveRolesSchema, driveRoles } from './tools/drive-roles.js';
+import { driveOrgSchema, driveOrg } from './tools/drive-org.js';
+import { driveDeleteSchema, driveDelete } from './tools/drive-delete.js';
+import { driveVersionsSchema, driveVersions } from './tools/drive-versions.js';
+import { driveSearchSchema, driveSearch } from './tools/drive-search.js';
+import { driveRecallSchema, driveRecall } from './tools/drive-recall.js';
+import { driveLogRunSchema, driveLogRun } from './tools/drive-log-run.js';
+import { driveContextSchema, driveContext } from './tools/drive-context.js';
+import { driveSandboxCloneSchema, driveSandboxClone } from './tools/drive-sandbox-clone.js';
+import { driveSandboxExecSchema, driveSandboxExec } from './tools/drive-sandbox-exec.js';
+import { driveSandboxReadSchema, driveSandboxRead } from './tools/drive-sandbox-read.js';
+import { driveSandboxCommitSchema, driveSandboxCommit } from './tools/drive-sandbox-commit.js';
+import { driveSessionsSchema, driveSessions } from './tools/drive-sessions.js';
+import { driveResumeSchema, driveResume } from './tools/drive-resume.js';
+// Shared by every MCP-aware host. Stdio and the hosted Streamable-HTTP server
+// surface the same guidance via the MCP `instructions` field at session start.
+export const SERVER_INSTRUCTIONS = `AgentDrive — cross-agent artifact workspace with provenance for multi-agent workflows.
+
+Reach for these tools without waiting to be asked:
+
+- **Session start:** call \`drive_context\` with a short summary of the
+  current task. Returns the most relevant artifacts and last_run
+  summaries from prior agents' work in the same workspace, each with
+  an \`attribution\` block explaining *why* it was surfaced.
+- **Continuing earlier work:** if the user is picking up where a prior
+  session left off (or a SessionStart note mentions prior sessions),
+  call \`drive_sessions\` to list this project's recent sessions across
+  harnesses, then \`drive_resume\` to load one's handoff brief.
+- **Cross-agent recall:** call \`drive_search\` (semantic) when the
+  user asks "what did Codex / Cursor / the last session do?"
+- **Saving work:** call \`drive_write\` for any artifact worth keeping
+  so the next agent in the chain can read it back.
+- **Provenance:** call \`drive_log_run\` at the end of meaningful
+  work so the cross-agent timeline stays accurate.
+
+Privacy: if the user has Private Workspace on, written content is
+encrypted client-side; the AgentDrive server only stores ciphertext.`;
+// Single source of truth for the 22 tools. Consumed by the stdio server
+// (packages/mcp-server/src/index.ts) and the hosted Streamable-HTTP endpoint
+// (apps/worker/src/routes/mcp.ts).
+export const TOOLS = [
+    { name: 'drive_write', description: 'Write a markdown file to a workspace. Creates or updates the file with automatic versioning.', schema: driveWriteSchema, handler: driveWrite },
+    { name: 'drive_read', description: "Read a file's content from a workspace.", schema: driveReadSchema, handler: driveRead },
+    { name: 'drive_list', description: 'List files in a workspace, optionally filtered by path prefix.', schema: driveListSchema, handler: driveList },
+    { name: 'drive_share', description: 'Generate a share link for a workspace or specific file. Optionally email-gate the link so only a specific person can access it. Humans open this link to view, comment, or edit files.', schema: driveShareSchema, handler: driveShare },
+    { name: 'drive_comment', description: 'Add a comment to a file.', schema: driveCommentSchema, handler: driveComment },
+    { name: 'drive_feedback', description: 'Read human comments on a file. Use this to check if humans have left feedback.', schema: driveFeedbackSchema, handler: driveFeedback },
+    { name: 'drive_activity', description: 'Get recent activity in a workspace (file writes, comments, shares).', schema: driveActivitySchema, handler: driveActivity },
+    { name: 'drive_invite', description: 'Invite a human to your organization by email. They will receive a verification code to join.', schema: driveInviteSchema, handler: driveInvite },
+    { name: 'drive_roles', description: 'Manage per-workspace role delegation. Assign, list, or remove access for specific emails (view/comment/edit).', schema: driveRolesSchema, handler: driveRoles },
+    { name: 'drive_org', description: 'View your organization details: agents, members, plan, and usage.', schema: driveOrgSchema, handler: driveOrg },
+    { name: 'drive_delete', description: 'Delete a file from a workspace.', schema: driveDeleteSchema, handler: driveDelete },
+    { name: 'drive_versions', description: 'View version history for a file in a workspace.', schema: driveVersionsSchema, handler: driveVersions },
+    { name: 'drive_search', description: "Semantic search across your org's artifacts in AgentDrive. Returns the top-N most relevant files. Use this BEFORE writing similar artifacts to avoid duplication and surface prior context.", schema: driveSearchSchema, handler: driveSearch },
+    { name: 'drive_recall', description: 'Recall persistent facts and preferences your agents have written. In v1 this returns semantic search results across artifacts; v1.5 will narrow to auto-extracted facts (preferences, decisions, key entities).', schema: driveRecallSchema, handler: driveRecall },
+    { name: 'drive_log_run', description: "Log an agent run to AgentDrive's provenance store. Captures task, status, referenced/produced artifacts, and cross-platform identity (which agent on which tool). Used for retrospective context retrieval and team-wide audit.", schema: driveLogRunSchema, handler: driveLogRun },
+    { name: 'drive_context', description: 'Auto-pull the most relevant artifacts from prior agent sessions for the task you are about to do. Combines semantic relevance with recency. Call this at the START of any non-trivial task to ground the agent in prior context — replaces manual copy-paste of artifacts between sessions.', schema: driveContextSchema, handler: driveContext },
+    { name: 'drive_sessions', description: 'List recent agent sessions for this project across harnesses (Claude Code, Codex, OpenCode, Gemini CLI, Cursor), newest first. Use to find prior work to continue.', schema: driveSessionsSchema, handler: driveSessions },
+    { name: 'drive_resume', description: "Load a compact handoff brief (goal, files touched, recent turns) from a prior session, by default the latest one from a different harness, so you can continue that work.", schema: driveResumeSchema, handler: driveResume },
+    { name: 'drive_sandbox_clone', description: '[EXPERIMENTAL] Clone a git repo into a per-workspace Linux sandbox. Requires Cloudflare Containers on the AgentDrive worker; gracefully degrades to a 503 with "sandbox not configured" otherwise.', schema: driveSandboxCloneSchema, handler: driveSandboxClone },
+    { name: 'drive_sandbox_exec', description: '[EXPERIMENTAL] Run a shell command inside the per-workspace Linux sandbox. Captures stdout/stderr (64 KB cap), exit code, duration. Requires Cloudflare Containers; degrades to 503 otherwise.', schema: driveSandboxExecSchema, handler: driveSandboxExec },
+    { name: 'drive_sandbox_read', description: '[EXPERIMENTAL] Read a file from the per-workspace sandbox filesystem (build artifacts, test output, logs). Requires Cloudflare Containers; degrades to 503 otherwise.', schema: driveSandboxReadSchema, handler: driveSandboxRead },
+    { name: 'drive_sandbox_commit', description: '[EXPERIMENTAL] Stage + commit the current sandbox worktree. Surfaces as an AgentDrive artifact at commits/<sha>.json. Requires Cloudflare Containers; degrades to 503 otherwise.', schema: driveSandboxCommitSchema, handler: driveSandboxCommit },
+];
+export { ApiClient } from './api-client.js';

package/dist/session.d.ts

@@ -0,0 +1,32 @@
+export type SessionHarness = 'claude-code' | 'codex' | 'opencode' | 'gemini-cli' | 'cursor';
+export interface SessionTool {
+    name: string;
+    path?: string;
+    summary?: string;
+}
+export interface SessionTurn {
+    role: string;
+    text: string;
+    ts?: string;
+    tools?: SessionTool[];
+}
+export interface SessionDoc {
+    harness: SessionHarness;
+    sessionId: string;
+    project: string;
+    cwd?: string;
+    title?: string;
+    updatedAt: string;
+    turns: SessionTurn[];
+    filesTouched: string[];
+}
+export declare function isEncrypted(content: string): boolean;
+export declare function sessionRunId(harness: SessionHarness, sessionId: string): string;
+export declare function sessionPath(project: string, harness: SessionHarness, sessionId: string): string;
+export declare function sessionActivityAt(run: {
+    created_at: number;
+    updated_at?: number;
+    metadata?: Record<string, unknown>;
+}): number;
+export declare function renderSession(doc: SessionDoc): string;
+export declare function buildHandoff(markdown: string, maxChars?: number): string;

package/dist/session.js

@@ -0,0 +1,158 @@
+// Must stay in sync with ENCRYPTED_PREFIX in packages/cli/src/lib/crypto.ts.
+const ENCRYPTED_PREFIX = 'agentdrive-encrypted:v0:';
+const DEFAULT_HANDOFF_CHARS = 12000;
+const GOAL_CHARS = 1500;
+const MAX_HANDOFF_FILES = 50;
+const TURN_HEADER = /^## ([a-z0-9_-]+)(?: {2}_\((.*)\)_)?$/;
+const TOOL_LINE = '> tool: ';
+// Turn text lines that could be read as a turn header or tool line get a
+// leading backslash so the parser never splits inside a turn body.
+const COLLIDING_LINE = /^\\*(## |> tool: )/;
+function oneLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function sanitizeId(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, '-').slice(0, 128);
+}
+function roleSlug(role) {
+    return role.toLowerCase().replace(/[^a-z0-9_-]/g, '') || 'system';
+}
+export function isEncrypted(content) {
+    return content.startsWith(ENCRYPTED_PREFIX);
+}
+export function sessionRunId(harness, sessionId) {
+    return `${harness}:${sanitizeId(sessionId)}`;
+}
+export function sessionPath(project, harness, sessionId) {
+    return `sessions/${project}/${harness}/${sanitizeId(sessionId)}.md`;
+}
+// Project listings are ordered by last activity, so ages must be shown from it too.
+export function sessionActivityAt(run) {
+    const at = run.metadata?.last_activity_at;
+    return typeof at === 'number' ? at : run.updated_at ?? run.created_at;
+}
+export function renderSession(doc) {
+    const out = [`# Session — ${doc.harness} / ${oneLine(doc.sessionId)}`, ''];
+    out.push(`Project: ${oneLine(doc.project)}`);
+    if (doc.cwd)
+        out.push(`Cwd: ${oneLine(doc.cwd)}`);
+    if (doc.title)
+        out.push(`Title: ${oneLine(doc.title)}`);
+    out.push(`Updated: ${oneLine(doc.updatedAt)}`);
+    out.push(`Turns: ${doc.turns.length}`);
+    out.push('', 'Files touched:');
+    for (const f of doc.filesTouched)
+        out.push(`- ${oneLine(f)}`);
+    for (const turn of doc.turns) {
+        out.push('', turn.ts ? `## ${roleSlug(turn.role)}  _(${oneLine(turn.ts)})_` : `## ${roleSlug(turn.role)}`, '');
+        const text = turn.text.replace(/\r\n?/g, '\n').trim();
+        if (text) {
+            for (const line of text.split('\n'))
+                out.push(COLLIDING_LINE.test(line) ? `\\${line}` : line);
+        }
+        if (turn.tools && turn.tools.length > 0) {
+            if (text)
+                out.push('');
+            for (const tool of turn.tools) {
+                const detail = tool.path ?? tool.summary;
+                out.push(`${TOOL_LINE}${oneLine(tool.name)}${detail ? ` ${oneLine(detail)}` : ''}`);
+            }
+        }
+    }
+    return `${out.join('\n')}\n`;
+}
+function parseSession(markdown) {
+    const parsed = { meta: [], files: [], turns: [] };
+    let current = null;
+    let inFiles = false;
+    for (const line of markdown.replace(/\r\n?/g, '\n').split('\n')) {
+        const header = TURN_HEADER.exec(line);
+        if (header) {
+            current = { role: header[1], lines: [line] };
+            parsed.turns.push(current);
+            continue;
+        }
+        if (current) {
+            current.lines.push(line);
+            continue;
+        }
+        const title = /^# Session — (\S+) \/ (.+)$/.exec(line);
+        if (title) {
+            parsed.harness = title[1];
+            parsed.sessionId = title[2];
+        }
+        else if (line === 'Files touched:') {
+            inFiles = true;
+        }
+        else if (inFiles && line.startsWith('- ')) {
+            parsed.files.push(line.slice(2));
+        }
+        else if (/^(Project|Cwd|Title|Updated|Turns): /.test(line)) {
+            parsed.meta.push(line);
+        }
+    }
+    return parsed;
+}
+function turnBody(turn) {
+    return turn.lines
+        .slice(1)
+        .filter((l) => !l.startsWith(TOOL_LINE))
+        .join('\n')
+        .trim();
+}
+function turnBlock(turn) {
+    const [header, ...rest] = turn.lines;
+    return [`#${header}`, ...rest].join('\n').trim();
+}
+function truncate(s, n) {
+    return s.length <= n ? s : `${s.slice(0, n - 3)}...`;
+}
+export function buildHandoff(markdown, maxChars = DEFAULT_HANDOFF_CHARS) {
+    const session = parseSession(markdown);
+    const from = session.harness ?? 'prior';
+    const intro = `Handoff from a ${from} session${session.sessionId ? ` (${session.sessionId})` : ''}. Continue this work; verify file state on disk before assuming it.`;
+    const sections = [intro];
+    if (session.meta.length > 0)
+        sections.push(session.meta.join('\n'));
+    const firstUser = session.turns.find((t) => t.role === 'user');
+    const goal = firstUser ? turnBody(firstUser) : '';
+    if (goal)
+        sections.push(`## Goal\n\n${truncate(goal, GOAL_CHARS)}`);
+    if (session.files.length > 0) {
+        const shown = session.files.slice(0, MAX_HANDOFF_FILES).map((f) => `- ${f}`);
+        const more = session.files.length - shown.length;
+        if (more > 0)
+            shown.push(`- (+${more} more)`);
+        sections.push(`## Files touched\n\n${shown.join('\n')}`);
+    }
+    if (session.turns.length === 0) {
+        const fixed = `${sections.join('\n\n')}\n\n## Transcript (tail)\n\n`;
+        const body = markdown.trim();
+        return (fixed + body.slice(Math.max(0, body.length - (maxChars - fixed.length)))).slice(0, maxChars);
+    }
+    const fixed = `${sections.join('\n\n')}\n\n## Recent turns\n\n`;
+    const markerReserve = 64;
+    let remaining = maxChars - fixed.length - markerReserve;
+    const picked = [];
+    for (let i = session.turns.length - 1; i >= 0 && remaining > 0; i--) {
+        const block = turnBlock(session.turns[i]);
+        if (block.length + 2 <= remaining) {
+            picked.unshift(block);
+            remaining -= block.length + 2;
+            continue;
+        }
+        if (picked.length === 0) {
+            const [header, ...rest] = block.split('\n');
+            const prefix = `${header}\n\n[... turn truncated ...]\n`;
+            const keep = remaining - prefix.length;
+            if (keep > 0) {
+                const body = rest.join('\n');
+                picked.unshift(prefix + body.slice(body.length - keep));
+            }
+        }
+        break;
+    }
+    const omitted = session.turns.length - picked.length;
+    const marker = omitted > 0 ? `[... ${omitted} earlier turns omitted ...]\n\n` : '';
+    return `${fixed}${marker}${picked.join('\n\n')}`.slice(0, maxChars);
+}

package/dist/tools/drive-context.d.ts

@@ -4,16 +4,15 @@ export declare const driveContextSchema: {
     task: z.ZodString;
     workspace_id: z.ZodOptional<z.ZodString>;
     limit: z.ZodOptional<z.ZodNumber>;
-    include_facts: z.ZodOptional<z.ZodBoolean>;
 };
 export declare function driveContext(client: ApiClient, args: {
     task: string;
     workspace_id?: string;
     limit?: number;
-    include_facts?: boolean;
 }): Promise<{
     content: {
         type: "text";
         text: string;
     }[];
 }>;
+export declare function relativeTime(ms: number): string;

package/dist/tools/drive-context.js

@@ -3,14 +3,12 @@ export const driveContextSchema = {
     task: z.string().min(1).max(2000).describe('What you are about to do — used to rank prior artifacts by relevance'),
     workspace_id: z.string().optional().describe('Scope to a single workspace; omit for org-wide context'),
     limit: z.number().int().positive().max(20).optional().describe('Max artifacts to return (default 5, max 20)'),
-    include_facts: z.boolean().optional().describe('Include extracted facts alongside artifacts (v1.5+)'),
 };
 export async function driveContext(client, args) {
     const { artifacts } = await client.context({
         task: args.task,
         workspace_id: args.workspace_id,
         limit: args.limit ?? 5,
-        include_facts: args.include_facts ?? false,
     });
     if (artifacts.length === 0) {
         return { content: [{ type: 'text', text: 'No prior context found.' }] };
@@ -33,7 +31,7 @@ function truncate(s, n) {
         return s;
     return s.slice(0, n - 1) + '...';
 }
-function relativeTime(ms) {
+export function relativeTime(ms) {
     if (ms < 0)
         return 'just now';
     const sec = Math.floor(ms / 1000);

package/dist/tools/drive-resume.d.ts

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveResumeSchema: {
+    session_id: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
+    max_chars: z.ZodOptional<z.ZodNumber>;
+};
+export declare function driveResume(client: ApiClient, args: {
+    session_id?: string;
+    platform?: string;
+    max_chars?: number;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-resume.js

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { buildHandoff, isEncrypted } from '../session.js';
+import { noProjectResult } from './drive-sessions.js';
+export const driveResumeSchema = {
+    session_id: z.string().optional().describe('Session run id from drive_sessions (e.g. codex:abc123); omit to pick the latest session from another harness'),
+    platform: z.string().optional().describe('When session_id is omitted, only consider sessions from this harness'),
+    max_chars: z.number().int().min(1000).max(50000).optional().describe('Handoff size budget in characters (default 12000)'),
+};
+function text(value) {
+    return { content: [{ type: 'text', text: value }] };
+}
+async function pickSession(client, project, platform) {
+    const { items } = await client.listRuns({ project, platform, limit: 20 });
+    return items.find((r) => r.agent_platform !== client.agentPlatform) ?? items[0];
+}
+export async function driveResume(client, args) {
+    let run;
+    if (args.session_id) {
+        run = await client.getRun(args.session_id);
+    }
+    else {
+        if (!client.project)
+            return noProjectResult();
+        run = await pickSession(client, client.project, args.platform);
+        if (!run)
+            return text(`No prior sessions for project ${client.project}.`);
+    }
+    const transcriptPath = run.metadata.transcript_path;
+    if (typeof transcriptPath !== 'string' || !run.workspace_id) {
+        return text(`Session ${run.run_id} has no uploaded transcript (missing metadata.transcript_path or workspace_id).`);
+    }
+    const file = await client.readFileByPath(run.workspace_id, transcriptPath);
+    if (isEncrypted(file.content)) {
+        return text(`This session is encrypted client-side; run \`adrive resume ${run.run_id}\` in a shell to view it.`);
+    }
+    return text(buildHandoff(file.content, args.max_chars));
+}

package/dist/tools/drive-search.d.ts

@@ -1,20 +1,20 @@
 import { z } from 'zod';
 import type { ApiClient } from '../api-client.js';
-declare const AGENT_PLATFORMS: readonly ["claude-code", "codex", "cursor", "langgraph", "crewai", "autogen", "hermes", "openclaw", "unknown"];
+declare const AGENT_PLATFORMS: readonly ["claude-code", "codex", "cursor", "langgraph", "crewai", "autogen", "hermes", "openclaw", "opencode", "gemini-cli", "unknown"];
 export declare const driveSearchSchema: {
     query: z.ZodString;
     workspace_id: z.ZodOptional<z.ZodString>;
     top_k: z.ZodOptional<z.ZodNumber>;
     filter: z.ZodOptional<z.ZodObject<{
-        agent_platform: z.ZodOptional<z.ZodEnum<["claude-code", "codex", "cursor", "langgraph", "crewai", "autogen", "hermes", "openclaw", "unknown"]>>;
+        agent_platform: z.ZodOptional<z.ZodEnum<["claude-code", "codex", "cursor", "langgraph", "crewai", "autogen", "hermes", "openclaw", "opencode", "gemini-cli", "unknown"]>>;
         agent_id: z.ZodOptional<z.ZodString>;
         path_prefix: z.ZodOptional<z.ZodString>;
     }, "strip", z.ZodTypeAny, {
-        agent_platform?: "claude-code" | "cursor" | "codex" | "langgraph" | "crewai" | "autogen" | "hermes" | "openclaw" | "unknown" | undefined;
+        agent_platform?: "claude-code" | "cursor" | "codex" | "langgraph" | "crewai" | "autogen" | "hermes" | "openclaw" | "opencode" | "gemini-cli" | "unknown" | undefined;
         agent_id?: string | undefined;
         path_prefix?: string | undefined;
     }, {
-        agent_platform?: "claude-code" | "cursor" | "codex" | "langgraph" | "crewai" | "autogen" | "hermes" | "openclaw" | "unknown" | undefined;
+        agent_platform?: "claude-code" | "cursor" | "codex" | "langgraph" | "crewai" | "autogen" | "hermes" | "openclaw" | "opencode" | "gemini-cli" | "unknown" | undefined;
         agent_id?: string | undefined;
         path_prefix?: string | undefined;
     }>>;

package/dist/tools/drive-search.js

@@ -8,6 +8,8 @@ const AGENT_PLATFORMS = [
     'autogen',
     'hermes',
     'openclaw',
+    'opencode',
+    'gemini-cli',
     'unknown',
 ];
 export const driveSearchSchema = {

package/dist/tools/drive-sessions.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import type { ApiClient } from '../api-client.js';
+export declare const driveSessionsSchema: {
+    project: z.ZodOptional<z.ZodString>;
+    platform: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+};
+export declare function noProjectResult(): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+};
+export declare function driveSessions(client: ApiClient, args: {
+    project?: string;
+    platform?: string;
+    limit?: number;
+}): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/drive-sessions.js

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { relativeTime } from './drive-context.js';
+import { sessionActivityAt } from '../session.js';
+export const driveSessionsSchema = {
+    project: z.string().regex(/^[a-z0-9._-]{1,200}$/).optional().describe('Project key; defaults to the project of the current working directory'),
+    platform: z.string().optional().describe('Only sessions from this harness (claude-code, codex, opencode, gemini-cli, cursor)'),
+    limit: z.number().int().positive().max(50).optional().describe('Max sessions to return (default 10, max 50)'),
+};
+export function noProjectResult() {
+    return {
+        content: [{
+                type: 'text',
+                text: 'No project key is known for this session. Pass `project` (e.g. github.com__owner__repo).',
+            }],
+    };
+}
+function sessionTitle(run) {
+    const title = run.metadata.title;
+    return typeof title === 'string' && title ? title : run.task;
+}
+export async function driveSessions(client, args) {
+    const project = args.project ?? client.project;
+    if (!project)
+        return noProjectResult();
+    const { items } = await client.listRuns({ project, platform: args.platform, limit: args.limit ?? 10 });
+    if (items.length === 0) {
+        return { content: [{ type: 'text', text: `No prior sessions for project ${project}.` }] };
+    }
+    const now = Date.now();
+    const lines = items.map((r) => {
+        const age = relativeTime(now - sessionActivityAt(r));
+        const uploaded = typeof r.metadata.files_uploaded === 'number' ? r.metadata.files_uploaded : r.artifacts_produced.length;
+        return `${age} · ${r.agent_platform} · ${sessionTitle(r)} · id=${r.run_id} · files_uploaded=${uploaded}`;
+    });
+    return {
+        content: [{
+                type: 'text',
+                text: `Sessions for ${project} (newest first):\n${lines.join('\n')}\n\nCall drive_resume with session_id to load one.`,
+            }],
+    };
+}

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@adrive/mcp-server",
-  "version": "0.4.0",
-  "description": "MCP server for AgentDrive — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph. Files, semantic search, run logging, cross-platform memory, and per-workspace agent sandboxing.",
+  "version": "1.1.0",
+  "description": "MCP server for AgentDrive — cross-agent artifact workspace with provenance and portable storage across Claude Code, Codex, Cursor, and LangGraph.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {
     "adrive-mcp": "dist/index.js"
   },
   "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./registry": "./dist/registry.js",
+    "./session": "./dist/session.js",
+    "./project": "./dist/project.js"
+  },
   "files": [
     "dist",
     "README.md"
@@ -15,8 +21,7 @@
   "homepage": "https://agentdrive.sh",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Rakesh1002/agentdrive.git",
-    "directory": "packages/mcp-server"
+    "url": "git+https://github.com/Rakesh1002/agentdrive-mcp.git"
   },
   "bugs": {
     "url": "https://github.com/Rakesh1002/agentdrive/issues"
@@ -35,12 +40,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run"
-  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.12.0",
     "zod": "^3.24.0"
@@ -49,5 +48,11 @@
     "@types/node": "^22.0.0",
     "typescript": "^5.7.0",
     "vitest": "^2.1.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
   }
-}
+}