agentrace 0.0.10 → 0.0.11

package/README.md

@@ -35,11 +35,15 @@ That's it! When you use Claude Code, sessions will be automatically sent to Agen
 | -------------------------------------------- | -------------------------------------- |
 | `agentrace init --url <url>`                 | Initial setup + hooks installation     |
 | `agentrace init --url <url> --proxy <proxy>` | Setup with proxy                       |
+| `agentrace init --url <url> --local`         | Setup for current project only         |
 | `agentrace login`                            | Open the web dashboard                 |
 | `agentrace send`                             | Send transcript diff (used by hooks)   |
 | `agentrace on`                               | Enable hooks                           |
+| `agentrace on --local`                       | Enable hooks for current project       |
 | `agentrace off`                              | Disable hooks                          |
+| `agentrace off --local`                      | Disable hooks for current project      |
 | `agentrace uninstall`                        | Remove hooks and configuration         |
+| `agentrace uninstall --local`                | Remove project-local settings only     |
 
 ## Command Details
 
@@ -48,7 +52,14 @@ That's it! When you use Claude Code, sessions will be automatically sent to Agen
 Sets up the server connection and installs Claude Code hooks.
 
 ```bash
+# Global setup (all projects)
 npx agentrace init --url http://localhost:9080
+
+# Project-local setup (current project only)
+npx agentrace init --url http://localhost:9080 --local
+
+# Project-local with separate config file
+npx agentrace init --url http://localhost:9080 --local --separate-local-config
 ```
 
 **Process flow:**
@@ -57,6 +68,15 @@ npx agentrace init --url http://localhost:9080
 2. After registration, API key is automatically retrieved
 3. Claude Code hooks are configured
 
+**Options:**
+
+| Option | Description |
+| ------ | ----------- |
+| `--url <url>` | Server URL (required) |
+| `--proxy <url>` | HTTP/HTTPS proxy URL |
+| `--local` | Install hooks/MCP for current project only |
+| `--separate-local-config` | Store config in project directory (requires --local) |
+
 ### login
 
 Issues a login URL for the web dashboard and opens it in browser.
@@ -70,11 +90,15 @@ npx agentrace login
 Toggle hooks enabled/disabled. Configuration is preserved.
 
 ```bash
-# Temporarily stop sending
+# Temporarily stop sending (global)
 npx agentrace off
 
-# Resume sending
+# Resume sending (global)
 npx agentrace on
+
+# For project-local settings
+npx agentrace off --local
+npx agentrace on --local
 ```
 
 ### uninstall
@@ -82,7 +106,11 @@ npx agentrace on
 Completely removes hooks and configuration files.
 
 ```bash
+# Remove global settings
 npx agentrace uninstall
+
+# Remove project-local settings only
+npx agentrace uninstall --local
 ```
 
 ### send
@@ -95,9 +123,28 @@ Configuration is stored in the following locations:
 
 | File                 | Location                          |
 | -------------------- | --------------------------------- |
-| AgenTrace config     | `~/.config/agentrace/config.json` |
-| Cursor data          | `~/.config/agentrace/cursors/`    |
+| AgenTrace config     | `~/.agentrace/config.json`        |
+| Cursor data          | `~/.agentrace/cursors/`           |
 | Claude Code hooks    | `~/.claude/settings.json`         |
+| MCP servers          | `~/.claude.json`                  |
+
+### Project-Local Configuration
+
+With the `--local` option, hooks and MCP are configured per-project:
+
+| File                 | Location                                       |
+| -------------------- | ---------------------------------------------- |
+| Claude Code hooks    | `{project}/.claude/settings.json`              |
+| MCP servers          | `~/.claude.json` (projects.{path}.mcpServers)  |
+| Config (optional)    | `{project}/.agentrace/config.json`             |
+
+To also store the config locally, use `--separate-local-config`:
+
+```bash
+npx agentrace init --url http://localhost:9080 --local --separate-local-config
+```
+
+**Note:** Add `.agentrace/` to your `.gitignore` when using `--separate-local-config` to avoid committing API keys.
 
 ## How It Works
 

package/dist/commands/init.d.ts

@@ -2,5 +2,7 @@ export interface InitOptions {
     url?: string;
     proxy?: string;
     dev?: boolean;
+    local?: boolean;
+    separateLocalConfig?: boolean;
 }
 export declare function initCommand(options?: InitOptions): Promise<void>;

package/dist/commands/init.js

@@ -1,7 +1,7 @@
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { ProxyAgent } from "undici";
-import { saveConfig, getConfigPath } from "../config/manager.js";
+import { saveConfig, getConfigPath, saveLocalConfig, getLocalConfigPath } from "../config/manager.js";
 import { installHooks, installMcpServer, installPreToolUseHook } from "../hooks/installer.js";
 import { startCallbackServer, getRandomPort, generateToken, } from "../utils/callback-server.js";
 import { openBrowser, buildSetupUrl } from "../utils/browser.js";
@@ -44,6 +44,11 @@ export async function initCommand(options = {}) {
     if (options.dev) {
         console.log("[Dev Mode] Using local CLI for hooks\n");
     }
+    if (options.local) {
+        console.log("[Local Mode] Installing hooks/MCP for this project only\n");
+    }
+    // Project directory for local scope
+    const projectDir = options.local ? process.cwd() : undefined;
     // Generate token and start callback server
     const token = generateToken();
     const port = getRandomPort();
@@ -73,12 +78,22 @@ export async function initCommand(options = {}) {
         const result = await callbackPromise;
         // Save config (remove trailing slash from URL)
         const serverUrlStr = serverUrl.toString().replace(/\/+$/, '');
-        saveConfig({
+        const configData = {
             server_url: serverUrlStr,
             api_key: result.apiKey,
             ...(options.proxy && { proxy_url: options.proxy }),
-        });
-        console.log(`✓ Config saved to ${getConfigPath()}`);
+        };
+        if (options.local && options.separateLocalConfig && projectDir) {
+            // Save config locally in project directory
+            saveLocalConfig(projectDir, configData);
+            console.log(`✓ Config saved to ${getLocalConfigPath(projectDir)}`);
+            console.log(`⚠ Remember to add '.agentrace/' to your .gitignore`);
+        }
+        else {
+            // Save config globally
+            saveConfig(configData);
+            console.log(`✓ Config saved to ${getConfigPath()}`);
+        }
         if (options.proxy) {
             console.log(`  Proxy: ${options.proxy}`);
         }
@@ -92,7 +107,11 @@ export async function initCommand(options = {}) {
             console.log(`  Hook command: ${hookCommand}`);
         }
         // Install hooks
-        const hookResult = installHooks({ command: hookCommand });
+        const hookResult = installHooks({
+            command: hookCommand,
+            local: options.local,
+            projectDir,
+        });
         if (hookResult.success) {
             console.log(`✓ ${hookResult.message}`);
         }
@@ -108,7 +127,12 @@ export async function initCommand(options = {}) {
             mcpCommand = "npx";
             mcpArgs = ["tsx", indexPath, "mcp-server"];
         }
-        const mcpResult = installMcpServer({ command: mcpCommand, args: mcpArgs });
+        const mcpResult = installMcpServer({
+            command: mcpCommand,
+            args: mcpArgs,
+            local: options.local,
+            projectDir,
+        });
         if (mcpResult.success) {
             console.log(`✓ ${mcpResult.message}`);
         }
@@ -116,7 +140,10 @@ export async function initCommand(options = {}) {
             console.error(`✗ ${mcpResult.message}`);
         }
         // Install PreToolUse hook for session_id injection
-        const preToolUseResult = installPreToolUseHook();
+        const preToolUseResult = installPreToolUseHook({
+            local: options.local,
+            projectDir,
+        });
         if (preToolUseResult.success) {
             console.log(`✓ ${preToolUseResult.message}`);
         }

package/dist/commands/mcp-server.js

@@ -126,7 +126,9 @@ IMPORTANT GUIDELINES:
     let client = null;
     function getClient() {
         if (!client) {
-            client = new PlanDocumentClient();
+            // Use CLAUDE_PROJECT_DIR to find local config if available
+            const projectDir = process.env.CLAUDE_PROJECT_DIR;
+            client = new PlanDocumentClient(projectDir);
         }
         return client;
     }

package/dist/commands/off.d.ts

@@ -1 +1,4 @@
-export declare function offCommand(): Promise<void>;
+export interface OffOptions {
+    local?: boolean;
+}
+export declare function offCommand(options?: OffOptions): Promise<void>;

package/dist/commands/off.js

@@ -1,29 +1,42 @@
 import { uninstallHooks, uninstallMcpServer, uninstallPreToolUseHook } from "../hooks/installer.js";
-import { loadConfig } from "../config/manager.js";
-export async function offCommand() {
-    // Check if config exists
-    const config = loadConfig();
+import { loadConfig, loadConfigWithFallback } from "../config/manager.js";
+export async function offCommand(options = {}) {
+    const projectDir = options.local ? process.cwd() : undefined;
+    // Check if config exists (local config takes precedence if --local is specified)
+    const config = options.local ? loadConfigWithFallback(projectDir) : loadConfig();
     if (!config) {
         console.log("AgenTrace is not configured. Run 'npx agentrace init' first.");
         return;
     }
-    const result = uninstallHooks();
+    if (options.local) {
+        console.log("[Local Mode] Disabling hooks/MCP for this project only\n");
+    }
+    const result = uninstallHooks({
+        local: options.local,
+        projectDir,
+    });
     if (result.success) {
         console.log(`✓ Hooks disabled. Your credentials are still saved.`);
-        console.log(`  Run 'npx agentrace on' to re-enable.`);
+        console.log(`  Run 'npx agentrace on${options.local ? " --local" : ""}' to re-enable.`);
     }
     else {
         console.error(`✗ ${result.message}`);
     }
     // Remove PreToolUse hook
-    const preToolUseResult = uninstallPreToolUseHook();
+    const preToolUseResult = uninstallPreToolUseHook({
+        local: options.local,
+        projectDir,
+    });
     if (preToolUseResult.success) {
         console.log(`✓ ${preToolUseResult.message}`);
     }
     else {
         console.error(`✗ ${preToolUseResult.message}`);
     }
-    const mcpResult = uninstallMcpServer();
+    const mcpResult = uninstallMcpServer({
+        local: options.local,
+        projectDir,
+    });
     if (mcpResult.success) {
         console.log(`✓ ${mcpResult.message}`);
     }

package/dist/commands/on.d.ts

@@ -1,4 +1,5 @@
 export interface OnOptions {
     dev?: boolean;
+    local?: boolean;
 }
 export declare function onCommand(options?: OnOptions): Promise<void>;

package/dist/commands/on.js

@@ -1,16 +1,20 @@
 import * as path from "node:path";
 import { fileURLToPath } from "node:url";
 import { installHooks, installMcpServer, installPreToolUseHook } from "../hooks/installer.js";
-import { loadConfig } from "../config/manager.js";
+import { loadConfig, loadConfigWithFallback } from "../config/manager.js";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export async function onCommand(options = {}) {
-    // Check if config exists
-    const config = loadConfig();
+    const projectDir = options.local ? process.cwd() : undefined;
+    // Check if config exists (local config takes precedence if --local is specified)
+    const config = options.local ? loadConfigWithFallback(projectDir) : loadConfig();
     if (!config) {
         console.log("AgenTrace is not configured. Run 'npx agentrace init' first.");
         return;
     }
+    if (options.local) {
+        console.log("[Local Mode] Enabling hooks/MCP for this project only\n");
+    }
     // Determine hook command
     let hookCommand;
     if (options.dev) {
@@ -19,7 +23,11 @@ export async function onCommand(options = {}) {
         const indexPath = path.join(cliRoot, "src/index.ts");
         hookCommand = `npx tsx ${indexPath} send`;
     }
-    const result = installHooks({ command: hookCommand });
+    const result = installHooks({
+        command: hookCommand,
+        local: options.local,
+        projectDir,
+    });
     if (result.success) {
         console.log(`✓ Hooks enabled. Session data will be sent to ${config.server_url}`);
     }
@@ -35,7 +43,12 @@ export async function onCommand(options = {}) {
         mcpCommand = "npx";
         mcpArgs = ["tsx", indexPath, "mcp-server"];
     }
-    const mcpResult = installMcpServer({ command: mcpCommand, args: mcpArgs });
+    const mcpResult = installMcpServer({
+        command: mcpCommand,
+        args: mcpArgs,
+        local: options.local,
+        projectDir,
+    });
     if (mcpResult.success) {
         console.log(`✓ ${mcpResult.message}`);
     }
@@ -43,7 +56,10 @@ export async function onCommand(options = {}) {
         console.error(`✗ ${mcpResult.message}`);
     }
     // Install PreToolUse hook for session_id injection
-    const preToolUseResult = installPreToolUseHook();
+    const preToolUseResult = installPreToolUseHook({
+        local: options.local,
+        projectDir,
+    });
     if (preToolUseResult.success) {
         console.log(`✓ ${preToolUseResult.message}`);
     }

package/dist/commands/send.js

@@ -1,5 +1,5 @@
 import { execSync } from "child_process";
-import { loadConfig } from "../config/manager.js";
+import { loadConfig, loadConfigWithFallback } from "../config/manager.js";
 import { getNewLines, saveCursor, hasCursor } from "../config/cursor.js";
 import { sendIngest } from "../utils/http.js";
 import { findSessionFile, extractCwdFromTranscript, } from "../utils/session-finder.js";
@@ -41,8 +41,8 @@ async function sendTranscript(params) {
         console.error(message);
         process.exit(isHook ? 0 : 1);
     };
-    // Check if config exists
-    const config = loadConfig();
+    // Check if config exists (local config takes precedence over global)
+    const config = loadConfigWithFallback(cwd);
     if (!config) {
         exitWithError("[agentrace] Warning: Config not found. Run 'npx agentrace init' first.");
         return;

package/dist/commands/uninstall.d.ts

@@ -1 +1,4 @@
-export declare function uninstallCommand(): Promise<void>;
+export interface UninstallOptions {
+    local?: boolean;
+}
+export declare function uninstallCommand(options?: UninstallOptions): Promise<void>;

package/dist/commands/uninstall.js

@@ -1,9 +1,18 @@
-import { deleteConfig } from "../config/manager.js";
+import { deleteConfig, deleteLocalConfig } from "../config/manager.js";
 import { uninstallHooks, uninstallMcpServer, uninstallPreToolUseHook } from "../hooks/installer.js";
-export async function uninstallCommand() {
-    console.log("Uninstalling AgenTrace...\n");
+export async function uninstallCommand(options = {}) {
+    const projectDir = options.local ? process.cwd() : undefined;
+    if (options.local) {
+        console.log("Uninstalling AgenTrace (local settings only)...\n");
+    }
+    else {
+        console.log("Uninstalling AgenTrace...\n");
+    }
     // Remove hooks
-    const hookResult = uninstallHooks();
+    const hookResult = uninstallHooks({
+        local: options.local,
+        projectDir,
+    });
     if (hookResult.success) {
         console.log(`✓ ${hookResult.message}`);
     }
@@ -11,7 +20,12 @@ export async function uninstallCommand() {
         console.error(`✗ ${hookResult.message}`);
     }
     // Remove PreToolUse hook
-    const preToolUseResult = uninstallPreToolUseHook();
+    const preToolUseResult = uninstallPreToolUseHook({
+        local: options.local,
+        projectDir,
+        // Don't remove the hook script when uninstalling local settings
+        removeScript: !options.local,
+    });
     if (preToolUseResult.success) {
         console.log(`✓ ${preToolUseResult.message}`);
     }
@@ -19,7 +33,10 @@ export async function uninstallCommand() {
         console.error(`✗ ${preToolUseResult.message}`);
     }
     // Remove MCP server
-    const mcpResult = uninstallMcpServer();
+    const mcpResult = uninstallMcpServer({
+        local: options.local,
+        projectDir,
+    });
     if (mcpResult.success) {
         console.log(`✓ ${mcpResult.message}`);
     }
@@ -27,12 +44,25 @@ export async function uninstallCommand() {
         console.error(`✗ ${mcpResult.message}`);
     }
     // Remove config
-    const configRemoved = deleteConfig();
-    if (configRemoved) {
-        console.log("✓ Config removed");
+    if (options.local && projectDir) {
+        // Remove local config directory
+        const configRemoved = deleteLocalConfig(projectDir);
+        if (configRemoved) {
+            console.log("✓ Local config removed (.agentrace/)");
+        }
+        else {
+            console.log("✓ No local config to remove");
+        }
     }
     else {
-        console.log("✓ No config to remove");
+        // Remove global config
+        const configRemoved = deleteConfig();
+        if (configRemoved) {
+            console.log("✓ Config removed");
+        }
+        else {
+            console.log("✓ No config to remove");
+        }
     }
     console.log("\nUninstall complete!");
 }

package/dist/config/manager.d.ts

@@ -7,3 +7,12 @@ export declare function getConfigPath(): string;
 export declare function loadConfig(): AgentraceConfig | null;
 export declare function saveConfig(config: AgentraceConfig): void;
 export declare function deleteConfig(): boolean;
+export declare function getLocalConfigDir(projectDir: string): string;
+export declare function getLocalConfigPath(projectDir: string): string;
+export declare function loadLocalConfig(projectDir: string): AgentraceConfig | null;
+export declare function saveLocalConfig(projectDir: string, config: AgentraceConfig): void;
+export declare function deleteLocalConfig(projectDir: string): boolean;
+/**
+ * Load config with fallback: local config > global config
+ */
+export declare function loadConfigWithFallback(projectDir?: string): AgentraceConfig | null;

package/dist/config/manager.js

@@ -36,3 +36,55 @@ export function deleteConfig() {
         return false;
     }
 }
+// --- Local (project-level) config functions ---
+export function getLocalConfigDir(projectDir) {
+    return path.join(projectDir, ".agentrace");
+}
+export function getLocalConfigPath(projectDir) {
+    return path.join(getLocalConfigDir(projectDir), "config.json");
+}
+export function loadLocalConfig(projectDir) {
+    const configFile = getLocalConfigPath(projectDir);
+    try {
+        if (!fs.existsSync(configFile)) {
+            return null;
+        }
+        const content = fs.readFileSync(configFile, "utf-8");
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+export function saveLocalConfig(projectDir, config) {
+    const localConfigDir = getLocalConfigDir(projectDir);
+    const localConfigFile = getLocalConfigPath(projectDir);
+    if (!fs.existsSync(localConfigDir)) {
+        fs.mkdirSync(localConfigDir, { recursive: true });
+    }
+    fs.writeFileSync(localConfigFile, JSON.stringify(config, null, 2));
+}
+export function deleteLocalConfig(projectDir) {
+    const localConfigDir = getLocalConfigDir(projectDir);
+    try {
+        if (fs.existsSync(localConfigDir)) {
+            fs.rmSync(localConfigDir, { recursive: true });
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Load config with fallback: local config > global config
+ */
+export function loadConfigWithFallback(projectDir) {
+    if (projectDir) {
+        const localConfig = loadLocalConfig(projectDir);
+        if (localConfig)
+            return localConfig;
+    }
+    return loadConfig();
+}

package/dist/config/manager.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/manager.test.js

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { getConfigPath, loadLocalConfig, saveLocalConfig, deleteLocalConfig, getLocalConfigPath, loadConfigWithFallback, } from "./manager.js";
+describe("config/manager", () => {
+    const testConfig = {
+        server_url: "http://localhost:8080",
+        api_key: "agtr_test_key",
+    };
+    describe("global config", () => {
+        it("getConfigPath returns expected path", () => {
+            expect(getConfigPath()).toBe(path.join(os.homedir(), ".agentrace", "config.json"));
+        });
+    });
+    describe("local config", () => {
+        let tempProjectDir;
+        beforeEach(() => {
+            tempProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentrace-project-"));
+        });
+        afterEach(() => {
+            if (fs.existsSync(tempProjectDir)) {
+                fs.rmSync(tempProjectDir, { recursive: true });
+            }
+        });
+        it("getLocalConfigPath returns correct path", () => {
+            const configPath = getLocalConfigPath(tempProjectDir);
+            expect(configPath).toBe(path.join(tempProjectDir, ".agentrace", "config.json"));
+        });
+        it("saveLocalConfig creates config file", () => {
+            saveLocalConfig(tempProjectDir, testConfig);
+            const configPath = getLocalConfigPath(tempProjectDir);
+            expect(fs.existsSync(configPath)).toBe(true);
+            const content = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            expect(content).toEqual(testConfig);
+        });
+        it("loadLocalConfig returns config when exists", () => {
+            saveLocalConfig(tempProjectDir, testConfig);
+            const loaded = loadLocalConfig(tempProjectDir);
+            expect(loaded).toEqual(testConfig);
+        });
+        it("loadLocalConfig returns null when config does not exist", () => {
+            const loaded = loadLocalConfig(tempProjectDir);
+            expect(loaded).toBeNull();
+        });
+        it("deleteLocalConfig removes config directory", () => {
+            saveLocalConfig(tempProjectDir, testConfig);
+            const configDir = path.join(tempProjectDir, ".agentrace");
+            expect(fs.existsSync(configDir)).toBe(true);
+            const result = deleteLocalConfig(tempProjectDir);
+            expect(result).toBe(true);
+            expect(fs.existsSync(configDir)).toBe(false);
+        });
+        it("deleteLocalConfig returns false when no config exists", () => {
+            const result = deleteLocalConfig(tempProjectDir);
+            expect(result).toBe(false);
+        });
+    });
+    describe("loadConfigWithFallback", () => {
+        let tempProjectDir;
+        const localConfig = {
+            server_url: "http://local:8080",
+            api_key: "test_local_key",
+        };
+        beforeEach(() => {
+            tempProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentrace-project-"));
+        });
+        afterEach(() => {
+            if (fs.existsSync(tempProjectDir)) {
+                fs.rmSync(tempProjectDir, { recursive: true });
+            }
+        });
+        it("returns local config when it exists", () => {
+            saveLocalConfig(tempProjectDir, localConfig);
+            const loaded = loadConfigWithFallback(tempProjectDir);
+            expect(loaded).toEqual(localConfig);
+        });
+        it("prefers local config over global config", () => {
+            // Save local config
+            saveLocalConfig(tempProjectDir, localConfig);
+            // loadConfigWithFallback should return local config
+            const loaded = loadConfigWithFallback(tempProjectDir);
+            expect(loaded).toEqual(localConfig);
+        });
+    });
+});

package/dist/hooks/installer.d.ts

@@ -1,34 +1,67 @@
 export interface InstallHooksOptions {
     command?: string;
+    local?: boolean;
+    projectDir?: string;
 }
 export declare function installHooks(options?: InstallHooksOptions): {
     success: boolean;
     message: string;
 };
-export declare function uninstallHooks(): {
+export interface UninstallHooksOptions {
+    local?: boolean;
+    projectDir?: string;
+}
+export declare function uninstallHooks(options?: UninstallHooksOptions): {
     success: boolean;
     message: string;
 };
-export declare function checkHooksInstalled(): boolean;
+export interface CheckHooksOptions {
+    local?: boolean;
+    projectDir?: string;
+}
+export declare function checkHooksInstalled(options?: CheckHooksOptions): boolean;
 export interface InstallMcpServerOptions {
     command?: string;
     args?: string[];
+    local?: boolean;
+    projectDir?: string;
 }
 export declare function installMcpServer(options?: InstallMcpServerOptions): {
     success: boolean;
     message: string;
 };
-export declare function uninstallMcpServer(): {
+export interface UninstallMcpServerOptions {
+    local?: boolean;
+    projectDir?: string;
+}
+export declare function uninstallMcpServer(options?: UninstallMcpServerOptions): {
     success: boolean;
     message: string;
 };
-export declare function checkMcpServerInstalled(): boolean;
-export declare function installPreToolUseHook(): {
+export interface CheckMcpServerOptions {
+    local?: boolean;
+    projectDir?: string;
+}
+export declare function checkMcpServerInstalled(options?: CheckMcpServerOptions): boolean;
+export interface InstallPreToolUseHookOptions {
+    local?: boolean;
+    projectDir?: string;
+}
+export declare function installPreToolUseHook(options?: InstallPreToolUseHookOptions): {
     success: boolean;
     message: string;
 };
-export declare function uninstallPreToolUseHook(): {
+export interface UninstallPreToolUseHookOptions {
+    local?: boolean;
+    projectDir?: string;
+    removeScript?: boolean;
+}
+export declare function uninstallPreToolUseHook(options?: UninstallPreToolUseHookOptions): {
     success: boolean;
     message: string;
 };
-export declare function checkPreToolUseHookInstalled(): boolean;
+export interface CheckPreToolUseHookOptions {
+    local?: boolean;
+    projectDir?: string;
+}
+export declare function checkPreToolUseHookInstalled(options?: CheckPreToolUseHookOptions): boolean;

package/dist/hooks/installer.js

@@ -1,12 +1,19 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
-const CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
+const GLOBAL_CLAUDE_SETTINGS_PATH = path.join(os.homedir(), ".claude", "settings.json");
 // MCP servers are configured in ~/.claude.json, NOT in settings.json
 const CLAUDE_CONFIG_PATH = path.join(os.homedir(), ".claude.json");
 // Agentrace hooks directory
 const AGENTRACE_HOOKS_DIR = path.join(os.homedir(), ".agentrace", "hooks");
 const SESSION_ID_HOOK_PATH = path.join(AGENTRACE_HOOKS_DIR, "inject-session-id.js");
+// Helper to get settings path based on local/global scope
+function getSettingsPath(options) {
+    if (options.local && options.projectDir) {
+        return path.join(options.projectDir, ".claude", "settings.json");
+    }
+    return GLOBAL_CLAUDE_SETTINGS_PATH;
+}
 const DEFAULT_COMMAND = "npx agentrace send";
 function createAgentraceHook(command) {
     return {
@@ -21,11 +28,12 @@ function isAgentraceHook(hook) {
 export function installHooks(options = {}) {
     const command = options.command || DEFAULT_COMMAND;
     const agentraceHook = createAgentraceHook(command);
+    const settingsPath = getSettingsPath(options);
     try {
         let settings = {};
         // Load existing settings if file exists
-        if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
-            const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        if (fs.existsSync(settingsPath)) {
+            const content = fs.readFileSync(settingsPath, "utf-8");
             settings = JSON.parse(content);
         }
         // Initialize hooks structure if not present
@@ -76,25 +84,26 @@ export function installHooks(options = {}) {
             });
         }
         // Ensure directory exists
-        const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+        const dir = path.dirname(settingsPath);
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
         }
         // Write settings
-        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
-        return { success: true, message: `Hooks added to ${CLAUDE_SETTINGS_PATH}` };
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        return { success: true, message: `Hooks added to ${settingsPath}` };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return { success: false, message: `Failed to install hooks: ${message}` };
     }
 }
-export function uninstallHooks() {
+export function uninstallHooks(options = {}) {
+    const settingsPath = getSettingsPath(options);
     try {
-        if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+        if (!fs.existsSync(settingsPath)) {
             return { success: true, message: "No settings file found" };
         }
-        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        const content = fs.readFileSync(settingsPath, "utf-8");
         const settings = JSON.parse(content);
         if (!settings.hooks) {
             return { success: true, message: "No hooks configured" };
@@ -131,10 +140,10 @@ export function uninstallHooks() {
         if (Object.keys(settings.hooks).length === 0) {
             delete settings.hooks;
         }
-        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
         return {
             success: true,
-            message: `Removed hooks from ${CLAUDE_SETTINGS_PATH}`,
+            message: `Removed hooks from ${settingsPath}`,
         };
     }
     catch (error) {
@@ -142,12 +151,13 @@ export function uninstallHooks() {
         return { success: false, message: `Failed to uninstall hooks: ${message}` };
     }
 }
-export function checkHooksInstalled() {
+export function checkHooksInstalled(options = {}) {
+    const settingsPath = getSettingsPath(options);
     try {
-        if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+        if (!fs.existsSync(settingsPath)) {
             return false;
         }
-        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        const content = fs.readFileSync(settingsPath, "utf-8");
         const settings = JSON.parse(content);
         const hasStopHook = settings.hooks?.Stop?.some((matcher) => matcher.hooks?.some(isAgentraceHook));
         const hasUserPromptSubmitHook = settings.hooks?.UserPromptSubmit?.some((matcher) => matcher.hooks?.some(isAgentraceHook));
@@ -172,63 +182,107 @@ export function installMcpServer(options = {}) {
             const content = fs.readFileSync(CLAUDE_CONFIG_PATH, "utf-8");
             config = JSON.parse(content);
         }
-        // Initialize mcpServers structure if not present
-        if (!config.mcpServers) {
-            config.mcpServers = {};
-        }
-        // Check if already installed
-        if (config.mcpServers[MCP_SERVER_NAME]) {
-            // Update existing config
+        if (options.local && options.projectDir) {
+            // Local scope: add to projects.{projectDir}.mcpServers
+            if (!config.projects) {
+                config.projects = {};
+            }
+            if (!config.projects[options.projectDir]) {
+                config.projects[options.projectDir] = {};
+            }
+            if (!config.projects[options.projectDir].mcpServers) {
+                config.projects[options.projectDir].mcpServers = {};
+            }
+            const projectMcpServers = config.projects[options.projectDir].mcpServers;
+            const alreadyExists = !!projectMcpServers[MCP_SERVER_NAME];
+            projectMcpServers[MCP_SERVER_NAME] = { command, args };
+            fs.writeFileSync(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2));
+            return {
+                success: true,
+                message: alreadyExists
+                    ? "MCP server config updated (local)"
+                    : `MCP server added to ${CLAUDE_CONFIG_PATH} (local scope for ${options.projectDir})`,
+            };
+        }
+        else {
+            // User scope: add to mcpServers (global)
+            if (!config.mcpServers) {
+                config.mcpServers = {};
+            }
+            const alreadyExists = !!config.mcpServers[MCP_SERVER_NAME];
             config.mcpServers[MCP_SERVER_NAME] = { command, args };
             fs.writeFileSync(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2));
-            return { success: true, message: "MCP server config updated" };
+            return {
+                success: true,
+                message: alreadyExists
+                    ? "MCP server config updated"
+                    : `MCP server added to ${CLAUDE_CONFIG_PATH}`,
+            };
         }
-        // Add MCP server config
-        config.mcpServers[MCP_SERVER_NAME] = { command, args };
-        // Write config
-        fs.writeFileSync(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2));
-        return { success: true, message: `MCP server added to ${CLAUDE_CONFIG_PATH}` };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return { success: false, message: `Failed to install MCP server: ${message}` };
     }
 }
-export function uninstallMcpServer() {
+export function uninstallMcpServer(options = {}) {
     try {
         if (!fs.existsSync(CLAUDE_CONFIG_PATH)) {
             return { success: true, message: "No config file found" };
         }
         const content = fs.readFileSync(CLAUDE_CONFIG_PATH, "utf-8");
         const config = JSON.parse(content);
-        if (!config.mcpServers || !config.mcpServers[MCP_SERVER_NAME]) {
-            return { success: true, message: "MCP server not configured" };
-        }
-        // Remove agentrace MCP server
-        delete config.mcpServers[MCP_SERVER_NAME];
-        // Clean up empty mcpServers object
-        if (Object.keys(config.mcpServers).length === 0) {
-            delete config.mcpServers;
+        if (options.local && options.projectDir) {
+            // Local scope: remove from projects.{projectDir}.mcpServers
+            if (!config.projects?.[options.projectDir]?.mcpServers?.[MCP_SERVER_NAME]) {
+                return { success: true, message: "MCP server not configured (local)" };
+            }
+            delete config.projects[options.projectDir].mcpServers[MCP_SERVER_NAME];
+            // Clean up empty mcpServers object
+            if (Object.keys(config.projects[options.projectDir].mcpServers).length === 0) {
+                delete config.projects[options.projectDir].mcpServers;
+            }
+            fs.writeFileSync(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2));
+            return {
+                success: true,
+                message: `Removed MCP server from ${CLAUDE_CONFIG_PATH} (local scope)`,
+            };
+        }
+        else {
+            // User scope: remove from mcpServers (global)
+            if (!config.mcpServers || !config.mcpServers[MCP_SERVER_NAME]) {
+                return { success: true, message: "MCP server not configured" };
+            }
+            delete config.mcpServers[MCP_SERVER_NAME];
+            // Clean up empty mcpServers object
+            if (Object.keys(config.mcpServers).length === 0) {
+                delete config.mcpServers;
+            }
+            fs.writeFileSync(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2));
+            return {
+                success: true,
+                message: `Removed MCP server from ${CLAUDE_CONFIG_PATH}`,
+            };
         }
-        fs.writeFileSync(CLAUDE_CONFIG_PATH, JSON.stringify(config, null, 2));
-        return {
-            success: true,
-            message: `Removed MCP server from ${CLAUDE_CONFIG_PATH}`,
-        };
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return { success: false, message: `Failed to uninstall MCP server: ${message}` };
     }
 }
-export function checkMcpServerInstalled() {
+export function checkMcpServerInstalled(options = {}) {
     try {
         if (!fs.existsSync(CLAUDE_CONFIG_PATH)) {
             return false;
         }
         const content = fs.readFileSync(CLAUDE_CONFIG_PATH, "utf-8");
         const config = JSON.parse(content);
-        return !!config.mcpServers?.[MCP_SERVER_NAME];
+        if (options.local && options.projectDir) {
+            return !!config.projects?.[options.projectDir]?.mcpServers?.[MCP_SERVER_NAME];
+        }
+        else {
+            return !!config.mcpServers?.[MCP_SERVER_NAME];
+        }
     }
     catch {
         return false;
@@ -276,7 +330,8 @@ function isAgentracePreToolUseHook(matcher) {
     return matcher.matcher === AGENTRACE_MCP_TOOLS_MATCHER &&
         matcher.hooks?.some(h => h.command?.includes("inject-session-id"));
 }
-export function installPreToolUseHook() {
+export function installPreToolUseHook(options = {}) {
+    const settingsPath = getSettingsPath(options);
     try {
         // Create hooks directory if not exists
         if (!fs.existsSync(AGENTRACE_HOOKS_DIR)) {
@@ -286,8 +341,8 @@ export function installPreToolUseHook() {
         fs.writeFileSync(SESSION_ID_HOOK_PATH, SESSION_ID_HOOK_SCRIPT, { mode: 0o755 });
         // Load existing settings
         let settings = {};
-        if (fs.existsSync(CLAUDE_SETTINGS_PATH)) {
-            const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        if (fs.existsSync(settingsPath)) {
+            const content = fs.readFileSync(settingsPath, "utf-8");
             settings = JSON.parse(content);
         }
         // Initialize hooks structure if not present
@@ -313,12 +368,12 @@ export function installPreToolUseHook() {
             ],
         });
         // Ensure directory exists
-        const dir = path.dirname(CLAUDE_SETTINGS_PATH);
+        const dir = path.dirname(settingsPath);
         if (!fs.existsSync(dir)) {
             fs.mkdirSync(dir, { recursive: true });
         }
         // Write settings
-        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
         return { success: true, message: `PreToolUse hook installed to ${SESSION_ID_HOOK_PATH}` };
     }
     catch (error) {
@@ -326,17 +381,18 @@ export function installPreToolUseHook() {
         return { success: false, message: `Failed to install PreToolUse hook: ${message}` };
     }
 }
-export function uninstallPreToolUseHook() {
+export function uninstallPreToolUseHook(options = {}) {
+    const settingsPath = getSettingsPath(options);
     try {
-        // Remove hook script
-        if (fs.existsSync(SESSION_ID_HOOK_PATH)) {
+        // Remove hook script only when uninstalling global hooks (not local)
+        if (!options.local && options.removeScript !== false && fs.existsSync(SESSION_ID_HOOK_PATH)) {
             fs.unlinkSync(SESSION_ID_HOOK_PATH);
         }
         // Remove from settings
-        if (!fs.existsSync(CLAUDE_SETTINGS_PATH)) {
+        if (!fs.existsSync(settingsPath)) {
             return { success: true, message: "No settings file found" };
         }
-        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        const content = fs.readFileSync(settingsPath, "utf-8");
         const settings = JSON.parse(content);
         if (!settings.hooks?.PreToolUse) {
             return { success: true, message: "No PreToolUse hooks configured" };
@@ -350,7 +406,7 @@ export function uninstallPreToolUseHook() {
         if (Object.keys(settings.hooks).length === 0) {
             delete settings.hooks;
         }
-        fs.writeFileSync(CLAUDE_SETTINGS_PATH, JSON.stringify(settings, null, 2));
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
         return { success: true, message: "PreToolUse hook removed" };
     }
     catch (error) {
@@ -358,12 +414,13 @@ export function uninstallPreToolUseHook() {
         return { success: false, message: `Failed to uninstall PreToolUse hook: ${message}` };
     }
 }
-export function checkPreToolUseHookInstalled() {
+export function checkPreToolUseHookInstalled(options = {}) {
+    const settingsPath = getSettingsPath(options);
     try {
-        if (!fs.existsSync(CLAUDE_SETTINGS_PATH) || !fs.existsSync(SESSION_ID_HOOK_PATH)) {
+        if (!fs.existsSync(settingsPath) || !fs.existsSync(SESSION_ID_HOOK_PATH)) {
             return false;
         }
-        const content = fs.readFileSync(CLAUDE_SETTINGS_PATH, "utf-8");
+        const content = fs.readFileSync(settingsPath, "utf-8");
         const settings = JSON.parse(content);
         return settings.hooks?.PreToolUse?.some(isAgentracePreToolUseHook) ?? false;
     }

package/dist/hooks/installer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/installer.test.js

@@ -0,0 +1,166 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { installHooks, uninstallHooks, checkHooksInstalled, installMcpServer, uninstallMcpServer, checkMcpServerInstalled, } from "./installer.js";
+describe("hooks/installer", () => {
+    describe("local hooks", () => {
+        let tempProjectDir;
+        beforeEach(() => {
+            tempProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentrace-project-"));
+        });
+        afterEach(() => {
+            if (fs.existsSync(tempProjectDir)) {
+                fs.rmSync(tempProjectDir, { recursive: true });
+            }
+        });
+        it("installHooks creates local settings.json", () => {
+            const result = installHooks({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(result.success).toBe(true);
+            const settingsPath = path.join(tempProjectDir, ".claude", "settings.json");
+            expect(fs.existsSync(settingsPath)).toBe(true);
+            const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+            expect(settings.hooks).toBeDefined();
+            expect(settings.hooks.Stop).toBeDefined();
+            expect(settings.hooks.UserPromptSubmit).toBeDefined();
+            expect(settings.hooks.SubagentStop).toBeDefined();
+            expect(settings.hooks.PostToolUse).toBeDefined();
+        });
+        it("installHooks with custom command", () => {
+            const customCommand = "npx custom-cli send";
+            const result = installHooks({
+                command: customCommand,
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(result.success).toBe(true);
+            const settingsPath = path.join(tempProjectDir, ".claude", "settings.json");
+            const settings = JSON.parse(fs.readFileSync(settingsPath, "utf-8"));
+            expect(settings.hooks.Stop[0].hooks[0].command).toBe(customCommand);
+        });
+        it("checkHooksInstalled returns true for local hooks", () => {
+            installHooks({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            const installed = checkHooksInstalled({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(installed).toBe(true);
+        });
+        it("checkHooksInstalled returns false when no local hooks", () => {
+            const installed = checkHooksInstalled({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(installed).toBe(false);
+        });
+        it("uninstallHooks removes local hooks", () => {
+            installHooks({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            const result = uninstallHooks({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(result.success).toBe(true);
+            const installed = checkHooksInstalled({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(installed).toBe(false);
+        });
+    });
+    describe("local MCP server", () => {
+        let tempProjectDir;
+        let claudeJsonPath;
+        let originalClaudeJson = null;
+        beforeEach(() => {
+            tempProjectDir = fs.mkdtempSync(path.join(os.tmpdir(), "agentrace-project-"));
+            claudeJsonPath = path.join(os.homedir(), ".claude.json");
+            // Backup original ~/.claude.json if exists
+            if (fs.existsSync(claudeJsonPath)) {
+                originalClaudeJson = fs.readFileSync(claudeJsonPath, "utf-8");
+            }
+        });
+        afterEach(() => {
+            if (fs.existsSync(tempProjectDir)) {
+                fs.rmSync(tempProjectDir, { recursive: true });
+            }
+            // Restore original ~/.claude.json
+            if (originalClaudeJson !== null) {
+                fs.writeFileSync(claudeJsonPath, originalClaudeJson);
+            }
+            else if (fs.existsSync(claudeJsonPath)) {
+                // If original didn't exist but now exists, we need to clean up
+                // But we should be careful not to delete user's actual config
+                // So we just leave it as is
+            }
+        });
+        it("installMcpServer adds to projects for local scope", () => {
+            const result = installMcpServer({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(result.success).toBe(true);
+            expect(result.message).toContain("local scope");
+            const claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath, "utf-8"));
+            expect(claudeJson.projects).toBeDefined();
+            expect(claudeJson.projects[tempProjectDir]).toBeDefined();
+            expect(claudeJson.projects[tempProjectDir].mcpServers).toBeDefined();
+            expect(claudeJson.projects[tempProjectDir].mcpServers.agentrace).toBeDefined();
+        });
+        it("checkMcpServerInstalled returns true for local MCP", () => {
+            installMcpServer({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            const installed = checkMcpServerInstalled({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(installed).toBe(true);
+        });
+        it("checkMcpServerInstalled returns false when no local MCP", () => {
+            const installed = checkMcpServerInstalled({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(installed).toBe(false);
+        });
+        it("uninstallMcpServer removes local MCP", () => {
+            installMcpServer({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            const result = uninstallMcpServer({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(result.success).toBe(true);
+            const installed = checkMcpServerInstalled({
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(installed).toBe(false);
+        });
+        it("installMcpServer with custom command and args", () => {
+            const result = installMcpServer({
+                command: "node",
+                args: ["custom-server.js"],
+                local: true,
+                projectDir: tempProjectDir,
+            });
+            expect(result.success).toBe(true);
+            const claudeJson = JSON.parse(fs.readFileSync(claudeJsonPath, "utf-8"));
+            const mcpConfig = claudeJson.projects[tempProjectDir].mcpServers.agentrace;
+            expect(mcpConfig.command).toBe("node");
+            expect(mcpConfig.args).toEqual(["custom-server.js"]);
+        });
+    });
+});

package/dist/index.js

@@ -15,8 +15,16 @@ program
     .requiredOption("--url <url>", "Server URL (required)")
     .option("--proxy <url>", "HTTP/HTTPS proxy URL")
     .option("--dev", "Use local CLI path for development")
+    .option("--local", "Install hooks/MCP for current project only (project-local scope)")
+    .option("--separate-local-config", "Store config in project directory (requires --local)")
     .action(async (options) => {
-    await initCommand({ url: options.url, proxy: options.proxy, dev: options.dev });
+    await initCommand({
+        url: options.url,
+        proxy: options.proxy,
+        dev: options.dev,
+        local: options.local,
+        separateLocalConfig: options.separateLocalConfig,
+    });
 });
 program
     .command("login")
@@ -39,21 +47,24 @@ program
 program
     .command("uninstall")
     .description("Remove agentrace hooks and config")
-    .action(async () => {
-    await uninstallCommand();
+    .option("--local", "Remove only project-local hooks/MCP/config")
+    .action(async (options) => {
+    await uninstallCommand({ local: options.local });
 });
 program
     .command("on")
     .description("Enable agentrace hooks (credentials preserved)")
     .option("--dev", "Use local CLI path for development")
+    .option("--local", "Enable hooks/MCP for current project only")
     .action(async (options) => {
-    await onCommand({ dev: options.dev });
+    await onCommand({ dev: options.dev, local: options.local });
 });
 program
     .command("off")
     .description("Disable agentrace hooks (credentials preserved)")
-    .action(async () => {
-    await offCommand();
+    .option("--local", "Disable hooks/MCP for current project only")
+    .action(async (options) => {
+    await offCommand({ local: options.local });
 });
 program
     .command("mcp-server")

package/dist/mcp/plan-document-client.d.ts

@@ -56,7 +56,7 @@ export interface UpdatePlanRequest {
 export declare class PlanDocumentClient {
     private serverUrl;
     private apiKey;
-    constructor();
+    constructor(projectDir?: string);
     private request;
     searchPlans(params?: SearchPlansParams): Promise<PlanDocument[]>;
     getPlan(id: string): Promise<PlanDocument>;

package/dist/mcp/plan-document-client.js

@@ -1,11 +1,11 @@
 import { fetch } from "undici";
-import { loadConfig } from "../config/manager.js";
+import { loadConfigWithFallback } from "../config/manager.js";
 import { createDispatcher } from "../utils/proxy.js";
 export class PlanDocumentClient {
     serverUrl;
     apiKey;
-    constructor() {
-        const config = loadConfig();
+    constructor(projectDir) {
+        const config = loadConfigWithFallback(projectDir);
         if (!config) {
             throw new Error("AgenTrace is not configured. Run 'npx agentrace init' first.");
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentrace",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "CLI for AgenTrace - Claude Code session tracker",
   "type": "module",
   "bin": {