fix(doctor): tighten staged-marketplace import proof and duplicate-hook matching

Address Codex review round 4 on #414:
- AB7323 only accepts a receipted cache entry whose segment matches the
  staged HEAD commit (or plugin version when the commit is unknown), and
  skips malformed cache entries instead of aborting Doctor.
- The staged plugins/<entry>/.cursor-plugin/plugin.json must be named
  <entry>, otherwise the repository is corrupt.
- AB7322 matches plugin paths on a component boundary so a sibling plugin
  with a shared path prefix is not flagged as duplicate delivery.

Author: ScriptedAlchemy

packages/agent-bundle/src/install/cursor-hooks-registration.ts

@@ -120,7 +120,17 @@ const userHookDuplicates = async (
     };
   }
   const resolvedPlugin = resolve(pluginDirectory);
-  const duplicates = parsed.commands.filter((command) => command.includes(resolvedPlugin));
+  // Match on a path-component boundary so `plugins/local/foo` does not claim hooks aimed at `plugins/local/foo-tools`.
+  const pointsIntoPlugin = (command: string): boolean => {
+    let offset = command.indexOf(resolvedPlugin);
+    while (offset !== -1) {
+      const next = command.charAt(offset + resolvedPlugin.length);
+      if (next === '' || next === '/' || /["'\s]/u.test(next)) return true;
+      offset = command.indexOf(resolvedPlugin, offset + 1);
+    }
+    return false;
+  };
+  const duplicates = parsed.commands.filter(pointsIntoPlugin);
   if (duplicates.length === 0) return { diagnostics: Object.freeze([]), duplicates: Object.freeze([]) };
   return {
     diagnostics: Object.freeze([finding(
@@ -233,29 +243,45 @@ export interface CursorMarketplaceStagingFinding {
 /**
  * Cursor's cache is partitioned per marketplace: `plugins/cache/<sanitize(marketplaceSlug)>/<pluginId>/<version>`
  * (observed 2026-09-03; e.g. `cache/cursor-public/continual-learning/<sha>/`), and Cursor writes an empty
- * `.cache-complete` receipt beside `.cursor-plugin/` once the copy finished. Only a receipted entry in the
- * staged marketplace's partition proves that *this* staged repository was imported; the same plugin cached
- * from another marketplace, or a half-written cache directory, does not.
+ * `.cache-complete` receipt beside `.cursor-plugin/` once the copy finished. The `<version>` segment observed
+ * for Git-backed marketplaces is the marketplace commit SHA. Only a receipted entry in the staged
+ * marketplace's partition whose segment matches the staged HEAD commit (or, when the commit is unknown,
+ * the plugin version) proves that *this* staged repository was imported; the same plugin cached from another
+ * marketplace, a receipt from an earlier staging commit, or a half-written cache directory, does not.
+ * Malformed cache entries are skipped rather than aborting Doctor.
  */
 const sanitizeCacheSegment = (segment: string): string => segment.replaceAll(/[^A-Za-z0-9._-]/gu, '-');
 
+const readableFile = async (path: string): Promise<boolean> => {
+  try {
+    await readFile(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
 const cacheHasPlugin = async (
   home: string,
   marketplace: string,
   name: string,
   version: string | undefined,
+  commit: string | undefined,
 ): Promise<boolean> => {
   const pluginRoot = join(home, '.cursor', 'plugins', 'cache', sanitizeCacheSegment(marketplace), sanitizeCacheSegment(name));
-  let versions: readonly string[];
+  let segments: readonly string[];
   try {
-    versions = await readdir(pluginRoot);
-  } catch (error) {
-    if (isErrno(error, 'ENOENT') || isErrno(error, 'ENOTDIR')) return false;
-    throw error;
+    segments = await readdir(pluginRoot);
+  } catch {
+    return false;
   }
-  for (const entry of versions) {
-    if (!(await exists(join(pluginRoot, entry, '.cache-complete')))) continue;
-    const installed = await readJson(join(pluginRoot, entry, '.cursor-plugin', 'plugin.json'));
+  const expectedSegments = new Set(
+    [commit, version].filter((candidate): candidate is string => candidate !== undefined).map(sanitizeCacheSegment),
+  );
+  for (const segment of segments) {
+    if (expectedSegments.size > 0 && !expectedSegments.has(segment)) continue;
+    if (!(await readableFile(join(pluginRoot, segment, '.cache-complete')))) continue;
+    const installed = await readJson(join(pluginRoot, segment, '.cursor-plugin', 'plugin.json'));
     if (installed.error !== undefined || !Predicate.isObject(installed.value)) continue;
     if (installed.value.name !== name) continue;
     if (version === undefined || installed.value.version === version) return true;
@@ -316,19 +342,20 @@ export const inspectCursorMarketplaceStaging = async (
     const listsPlugin = manifest.error === undefined && Predicate.isObject(manifest.value) && Array.isArray(manifest.value.plugins) &&
       manifest.value.plugins.some((candidate: unknown) =>
         Predicate.isObject(candidate) && candidate.name === entry && candidate.source === `plugins/${entry}`);
-    if (marketplace === undefined || !listsPlugin || plugin.error !== undefined || !(await exists(join(path, '.git')))) {
+    const pluginNamed = plugin.error === undefined && Predicate.isObject(plugin.value) && plugin.value.name === entry;
+    if (marketplace === undefined || !listsPlugin || !pluginNamed || !(await exists(join(path, '.git')))) {
       findings.push({ entry, name: entry, path, state: 'corrupt', ...(marketplace === undefined ? {} : { marketplace }) });
       diagnostics.push(finding(
         'AB7323',
         `Staged Cursor marketplace ${JSON.stringify(path)} is incomplete (marketplace.json missing or not listing ` +
-          `${entry} at plugins/${entry}, plugin manifest missing, or no .git).`,
+          `${entry} at plugins/${entry}, plugins/${entry}/.cursor-plugin/plugin.json missing or not named ${entry}, or no .git).`,
         'Remove the staged directory and rerun `agent-bundle install cursor --mode marketplace`.',
         'error',
       ));
       continue;
     }
     const commit = await readHeadCommit(path);
-    const registered = await cacheHasPlugin(home, marketplace, entry, version);
+    const registered = await cacheHasPlugin(home, marketplace, entry, version, commit);
     findings.push({
       ...(commit === undefined ? {} : { commit }),
       entry,

packages/agent-bundle/tests/doctor.test.ts

@@ -1,4 +1,4 @@
-import { cp, mkdir, mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
+import { cp, mkdir, mkdtemp, readFile, rm, symlink, writeFile } from 'node:fs/promises';
 import { spawn, type ChildProcess } from 'node:child_process';
 import { createServer, type Server, type Socket } from 'node:net';
 import { tmpdir } from 'node:os';
@@ -1496,6 +1496,15 @@ it('proves plugin-scoped Cursor hook registration and flags stale, missing, and
     expect(hostReport(await doctor(), 'cursor').inventory.findings[0]?.hooks).toMatchObject({ state: 'stale' });
     await writeHookedCursorPlugin(pluginRoot);
 
+    // A sibling plugin whose path shares this plugin's path as a prefix must not count as duplicate delivery.
+    await writeJson(join(fixture.home, '.cursor', 'hooks.json'), {
+      hooks: { preToolUse: [{ command: `node ${pluginRoot}-tools/hooks/before-tool.mjs` }] },
+      version: 1,
+    });
+    const sibling = await doctor();
+    expect(hostReport(sibling, 'cursor').inventory.findings[0]?.hooks).toMatchObject({ duplicates: [], state: 'registered' });
+    expect(hookDiagnostics(sibling).map((entry) => entry.code)).toEqual(['AB7321']);
+
     await writeJson(join(fixture.home, '.cursor', 'hooks.json'), {
       hooks: { preToolUse: [{ command: `node ${join(pluginRoot, 'hooks/before-tool.mjs')}` }] },
       version: 1,
@@ -1596,11 +1605,20 @@ it('tracks staged Cursor marketplaces from staged to imported', async () => {
     expect(hostReport(foreign, 'cursor').inventory.findings).toEqual([{ ...stagedFinding, state: 'unregistered' }]);
 
     // A cache directory without Cursor's `.cache-complete` receipt is a half-written copy, not an import.
-    const cached = join(fixture.home, '.cursor', 'plugins', 'cache', 'doctor-fixture-marketplace', 'doctor-fixture', commit);
+    const cacheRoot = join(fixture.home, '.cursor', 'plugins', 'cache', 'doctor-fixture-marketplace', 'doctor-fixture');
+    const cached = join(cacheRoot, commit);
     await writeJson(join(cached, '.cursor-plugin', 'plugin.json'), { name: 'doctor-fixture', version: '1.2.3' });
     const incomplete = await doctor();
     expect(hostReport(incomplete, 'cursor').inventory.findings).toEqual([{ ...stagedFinding, state: 'unregistered' }]);
 
+    // A receipted copy from an earlier staging commit, or a malformed cache entry, does not prove this commit was imported.
+    const previous = join(cacheRoot, 'b'.repeat(40));
+    await writeJson(join(previous, '.cursor-plugin', 'plugin.json'), { name: 'doctor-fixture', version: '1.2.3' });
+    await writeFile(join(previous, '.cache-complete'), '');
+    await writeFile(join(cacheRoot, 'not-a-directory'), 'stray');
+    const staleReceipt = await doctor();
+    expect(hostReport(staleReceipt, 'cursor').inventory.findings).toEqual([{ ...stagedFinding, state: 'unregistered' }]);
+
     await writeFile(join(cached, '.cache-complete'), '');
     const imported = await doctor();
     expect(hostReport(imported, 'cursor').inventory.findings).toEqual([{ ...stagedFinding, state: 'registered' }]);
@@ -1627,6 +1645,19 @@ it('tracks staged Cursor marketplaces from staged to imported', async () => {
     const corruptBundle = await doctor();
     expect(hostReport(corruptBundle, 'cursor').bundle?.state).toBe('corrupt');
 
+    // A plugin manifest naming a different plugin than the entry is corrupt even with a valid marketplace entry.
+    await writeJson(join(repo, '.cursor-plugin/marketplace.json'), {
+      name: 'doctor-fixture-marketplace',
+      owner: { name: 'doctor-fixture' },
+      plugins: [{ name: 'doctor-fixture', source: 'plugins/doctor-fixture' }],
+    });
+    const stagedManifest = await readFile(join(repo, 'plugins', 'doctor-fixture', '.cursor-plugin', 'plugin.json'), 'utf8');
+    await writeJson(join(repo, 'plugins', 'doctor-fixture', '.cursor-plugin', 'plugin.json'), { name: 'someone-else', version: '1.2.3' });
+    const misnamed = await doctor();
+    expect(hostReport(misnamed, 'cursor').inventory.findings).toEqual([expect.objectContaining({ entry: 'doctor-fixture', state: 'corrupt' })]);
+    expect(misnamed.diagnostics.filter((entry) => entry.code === 'AB7323')[0]?.message).toContain('not named doctor-fixture');
+    await writeFile(join(repo, 'plugins', 'doctor-fixture', '.cursor-plugin', 'plugin.json'), stagedManifest);
+
     await rm(join(repo, '.git'), { recursive: true });
     const corrupt = await doctor();
     expect(hostReport(corrupt, 'cursor').inventory.findings).toEqual([expect.objectContaining({ entry: 'doctor-fixture', state: 'corrupt' })]);