fix(extension): MCP server reads --workspace flag; live hooks state; drop footer Reindex/Reset

Three issues from real Cursor install testing:

**1. axme_context resolves to /home/$USER instead of the workspace.**
When Cursor spawns the MCP server via cursor.mcp.registerServer, the cwd
it picks is the user's home directory — not the workspace root — so the
server's process.cwd() defaults defaultProjectPath to /home/$USER. Calls
to axme_context without an explicit project_path then look up
`.axme-code/` in the wrong place and report "project not initialised",
even after a successful setup in the real workspace. The user's diagnostic
made this obvious: "STORAGE ROOT: /home/georgeb/.axme-code, которого не
существует" while the project's `.axme-code/` was sitting in /tmp/.

Fix: src/server.ts now resolves its root in this order:
  1. --workspace <abs> CLI flag (passed by the Cursor extension at
     registration time — see registerMcpServer)
  2. AXME_WORKSPACE env var (escape hatch for hand-spawned servers)
  3. process.cwd() (preserves Claude Code CLI behaviour where the binary
     is spawned from the project root and cwd already points there)

Extension passes workspaceFolders[0].uri.fsPath to registerMcpServer so
the server's defaultProjectPath always matches what the user thinks is
"the project". Verified via stdio smoke test: server reports
`Project: /tmp/axme-cwd-test` after --workspace /tmp/axme-cwd-test.

**2. Sidebar showed "hooks missing" when they were installed.**
The activation ActivationReport's hooks-step flag captures one moment in
time. After reinstall / reset cycles the sidebar's `S.hooksOk` could
stay stale until the next window reload. Added extension/src/hooks-state.ts
which reads ~/.cursor/hooks.json on demand and confirms preToolUse /
postToolUse / sessionEnd entries each contain `axme-code`. Sidebar pushes
this live value both on attach and on every resolveWebviewView, so the
report's snapshot is no longer the source of truth.

**3. Reindex / Reset buttons in the sidebar footer fired without obvious
feedback** and (per user feedback) were doing destructive-ish things from
a place the user expected to be lightweight monitoring. Removed both
from the sidebar footer. Healthcheck stays — it's a read-only webview.
The commands are still registered and reachable via the Command Palette
("AXME: Reindex semantic search" / "AXME: Reset"), where the modal
confirmation flow makes their effect more obviously deliberate.

Verified: npm test → 608 / 608 pass; self-test 6 / 6 pass on rebuilt
bundled binary; vsce package → 533 KB .vsix.

#!axme pr=none repo=AxmeAI/axme-code

Author: George-iam

extension/src/extension.ts

@@ -117,8 +117,14 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
   }
 
   // ---- Step 3: MCP registration ------------------------------------------
+  // We need the workspace folder BEFORE Step 6 — pass it to mcp-register so
+  // the server's --workspace flag points at the real project, not Cursor's
+  // home-dir cwd. Without this, axme_context called with no project_path
+  // defaults to /home/$USER and misses the workspace's .axme-code/ entirely.
+  const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+  const workspaceRoot = workspaceFolder?.uri.fsPath;
   await runStep(report, "mcp", () => "registered", async () => {
-    const disposable = await registerMcpServer(binary);
+    const disposable = await registerMcpServer(binary, workspaceRoot);
     context.subscriptions.push(disposable);
   });
 
@@ -157,8 +163,7 @@ export async function activate(context: vscode.ExtensionContext): Promise<void>
   // ---- Step 6: setup offer (non-blocking, fire-and-forget) ---------------
   // Setup is the user's job, not part of activation. We only record whether
   // the workspace is already initialised; the offer toast fires async and
-  // the user can decline.
-  const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+  // the user can decline. workspaceFolder was resolved earlier in Step 3.
   if (workspaceFolder) {
     const initialized = isAxmeInitialized();
     if (initialized) {

extension/src/hooks-state.ts

@@ -0,0 +1,41 @@
+/**
+ * Live read of ~/.cursor/hooks.json to confirm AXME entries are present.
+ *
+ * The sidebar previously inferred "hooks ok / missing" from the activation
+ * ActivationReport, which captured one moment in time. After a user
+ * reinstalls or reset and reinstalls hooks, the report stays stale until
+ * the next window reload. Reading the file on demand is cheap and never
+ * lies — if the entries exist on disk, the hook will fire next tool call.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export function hooksAreInstalled(): boolean {
+  const p = join(homedir(), ".cursor", "hooks.json");
+  if (!existsSync(p)) return false;
+  try {
+    const raw = readFileSync(p, "utf-8");
+    // We don't fully parse the schema here — a substring match on the
+    // binary name and any of the three lifecycle hook keys is enough to
+    // tell "AXME left its fingerprints in this file". installUserHooks
+    // is the canonical writer; if it has run successfully, all three
+    // keys will be present with our command path.
+    const parsed = JSON.parse(raw);
+    const hooks = parsed?.hooks;
+    if (!hooks || typeof hooks !== "object") return false;
+    for (const kind of ["preToolUse", "postToolUse", "sessionEnd"] as const) {
+      const list = hooks[kind];
+      if (!Array.isArray(list)) return false;
+      const hasAxme = list.some(
+        (entry: { command?: unknown }) =>
+          typeof entry?.command === "string" && entry.command.includes("axme-code"),
+      );
+      if (!hasAxme) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}

extension/src/mcp-register.ts

@@ -31,7 +31,10 @@ function getCursorMcpApi(): CursorMcpApi | undefined {
   return v.cursor?.mcp;
 }
 
-export async function registerMcpServer(binary: string): Promise<vscode.Disposable> {
+export async function registerMcpServer(
+  binary: string,
+  workspaceRoot: string | undefined,
+): Promise<vscode.Disposable> {
   const cursor = getCursorMcpApi();
   if (!cursor?.registerServer) {
     throw new Error(
@@ -40,11 +43,18 @@ export async function registerMcpServer(binary: string): Promise<vscode.Disposab
         "that lacks vscode.cursor.mcp.",
     );
   }
+  // Pass --workspace explicitly. Cursor spawns the MCP server from the
+  // user's home dir regardless of which workspace is open, so the server's
+  // process.cwd() is useless for resolving `.axme-code/`. Without this
+  // flag, axme_context defaults project_path to /home/$USER and reports
+  // "project not initialised" even after a successful setup in the real
+  // workspace. The server's resolveServerRoot() reads this flag.
+  const args = workspaceRoot ? ["serve", "--workspace", workspaceRoot] : ["serve"];
   cursor.registerServer({
     name: "axme",
-    server: { command: binary, args: ["serve"], env: {} },
+    server: { command: binary, args, env: {} },
   });
-  log(`MCP: registered 'axme' (binary=${binary})`);
+  log(`MCP: registered 'axme' (binary=${binary}, workspace=${workspaceRoot ?? "(none)"})`);
   // Cursor needs ~3s to process the registration before tools become
   // available to the chat agent. Verified empirically against the
   // browser-devtools-mcp reference implementation.

extension/src/sidebar-webview.ts

@@ -21,6 +21,7 @@ import { KbWatcher, KbCounts, readCounts } from "./kb-watcher.js";
 import { readBacklog, BacklogItemLite } from "./backlog-reader.js";
 import { readActiveSession, ActiveSession } from "./session-tracker.js";
 import { detectCurrentMode } from "./auditor-auth.js";
+import { hooksAreInstalled } from "./hooks-state.js";
 import { log } from "./log.js";
 
 /**
@@ -98,6 +99,10 @@ export class AxmeSidebarProvider implements vscode.WebviewViewProvider {
         this.push({ counts, backlog: readBacklog(workspaceRoot).slice(0, 5) });
       });
     }
+    // Push the live disk state for hooks. This overrides the activation
+    // report's snapshot (which can be stale after a reinstall or after
+    // installUserHooks's first-run race).
+    this.push({ hooksOk: hooksAreInstalled() });
     // Fire-and-forget auditor credential probe so the sidebar can render
     // the "Configure credential…" banner accurately on first open.
     void this.refreshAuthState();
@@ -118,10 +123,20 @@ export class AxmeSidebarProvider implements vscode.WebviewViewProvider {
     webviewView.webview.html = this.renderHtml(webviewView.webview);
     webviewView.webview.onDidReceiveMessage((m: SidebarMessage) => this.onMessage(m));
 
-    // Push the initial snapshot once webview is alive.
+    // Push the initial snapshot once webview is alive. Hooks state is
+    // read from disk on every reveal so reinstalls / external edits to
+    // ~/.cursor/hooks.json show up the next time the sidebar comes into
+    // view, not just at activation time.
     const counts = this.workspaceRoot ? readCounts(this.workspaceRoot) : emptyCounts();
     const backlog = this.workspaceRoot ? readBacklog(this.workspaceRoot).slice(0, 5) : [];
-    this.push({ ...this.initialState, counts, backlog, warnTokens: SESSION_WARN_TOKENS, ...this.pendingState });
+    this.push({
+      ...this.initialState,
+      counts,
+      backlog,
+      hooksOk: hooksAreInstalled(),
+      warnTokens: SESSION_WARN_TOKENS,
+      ...this.pendingState,
+    });
     this.pendingState = {};
 
     // Session polling — only runs while the view is visible. VS Code fires
@@ -234,9 +249,14 @@ export class AxmeSidebarProvider implements vscode.WebviewViewProvider {
 
   <footer>
     <button class="link" data-cmd="axme.showStatus">Healthcheck…</button>
-    <button class="link" data-cmd="axme.reindex">Reindex</button>
-    <button class="link" data-cmd="axme.reset">Reset</button>
   </footer>
+  <!--
+    Reindex / Reset removed from the sidebar footer per user feedback —
+    they ran a destructive or hard-to-undo flow without enough visible
+    feedback inline. The commands stay registered and accessible via
+    the Command Palette (AXME: Reindex semantic search / AXME: Reset),
+    where the modal-driven flow is more obviously a deliberate action.
+  -->
 
   <script nonce="${nonce}">${SIDEBAR_JS}</script>
 </body>

src/server.ts

@@ -41,9 +41,31 @@ import {
 import { logEvent } from "./storage/worklog.js";
 import { spawnDetachedAuditWorker } from "./audit-spawner.js";
 
-// --- Server state (detected at startup from cwd) ---
+// --- Server state (detected at startup from --workspace flag or cwd) ---
+//
+// When the Cursor extension registers the MCP server it cannot control the
+// cwd Cursor uses to spawn us — empirically Cursor spawns from the user's
+// home directory regardless of which workspace is open. Falling back to
+// cwd makes the server report a wrong `defaultProjectPath` and tools like
+// axme_context (called without explicit project_path) look up
+// `.axme-code/` in the wrong place. The fix is the extension passing
+// `--workspace <abs>` at registration time so the server has the right
+// root from the first tool call.
+//
+// Resolution order:
+//   1. --workspace <path> CLI flag (passed by the Cursor extension)
+//   2. AXME_WORKSPACE env var (escape hatch for hand-spawned servers)
+//   3. process.cwd() (legacy Claude Code CLI behaviour — server spawns
+//      from the project root so cwd already points at the right place)
+function resolveServerRoot(): string {
+  const argv = process.argv;
+  const flagIdx = argv.indexOf("--workspace");
+  if (flagIdx > -1 && argv[flagIdx + 1]) return argv[flagIdx + 1];
+  if (process.env.AXME_WORKSPACE) return process.env.AXME_WORKSPACE;
+  return process.cwd();
+}
 
-const serverCwd = process.cwd();
+const serverCwd = resolveServerRoot();
 const serverHasGit = existsSync(join(serverCwd, ".git"));
 const serverWorkspace = detectWorkspace(serverCwd);
 const isWorkspace = serverHasGit ? false : serverWorkspace.type !== "single";