@@ -31,7 +31,7 @@ They are not written into the project's `AGENTS.md`. Each tool gets its own file
 |---|---|---|
 | Claude Code | `~/.claude/CLAUDE.md` | `.claude/rules/teamai-context.md` |
 | Codex family | `$CODEX_HOME/AGENTS.md` | session-start hook |
-| Cursor | `~/.cursor/rules/teamai-context.mdc` | `.cursor/rules/teamai-context.mdc` |
+| Cursor | `~/.cursor/rules/teamai-context.mdc`; in a workspace outside the home directory, the session-start hook | `.cursor/rules/teamai-context.mdc` |
 | CodeBuddy, WorkBuddy | each tool's user file | one shared `.codebuddy/rules/teamai-context.md` |
 | OpenCode | `~/.config/opencode/teamai-context.md` | `.opencode/teamai-context.md` |
 | Pi, Oh My Pi | each tool's user file | an extension adds them to the system prompt |
 
@@ -31,7 +31,7 @@ team:
 |---|---|---|
 | Claude Code | `~/.claude/CLAUDE.md` | `.claude/rules/teamai-context.md` |
 | Codex 系列 | `$CODEX_HOME/AGENTS.md` | session-start hook |
-| Cursor | `~/.cursor/rules/teamai-context.mdc` | `.cursor/rules/teamai-context.mdc` |
+| Cursor | `~/.cursor/rules/teamai-context.mdc`；工作区不在主目录下时由 session-start hook 加入 | `.cursor/rules/teamai-context.mdc` |
 | CodeBuddy、WorkBuddy | 各自的用户文件 | 共用 `.codebuddy/rules/teamai-context.md` |
 | OpenCode | `~/.config/opencode/teamai-context.md` | `.opencode/teamai-context.md` |
 | Pi、Oh My Pi | 各自的用户文件 | 扩展加进系统提示 |
 
@@ -0,0 +1,125 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'node:path';
+import os from 'node:os';
+import fse from 'fs-extra';
+
+import { buildHandlerRegistry } from '../hook-handlers.js';
+import type { LocalConfig } from '../types.js';
+
+describe('Cursor gets the user-scope rules from its session-start hook in a workspace outside the home directory (#1197)', () => {
+  let tmpDir: string;
+  let home: string;
+  let userRepo: string;
+  let userConfig: LocalConfig;
+
+  const context = async (cwd: string, tool = 'cursor', config: LocalConfig | null = userConfig): Promise<string | null> => {
+    const registration = buildHandlerRegistry().find((r) => r.event === 'session-start' && r.handler.name === 'cursor-user-rules');
+    const output = await registration!.handler.execute({ hook_event_name: 'SessionStart', cwd }, tool, config);
+    if (output === null) return null;
+    const parsed = JSON.parse(output) as { hookSpecificOutput: { hookEventName: string; additionalContext: string } };
+    expect(parsed.hookSpecificOutput.hookEventName).toBe('SessionStart');
+    return parsed.hookSpecificOutput.additionalContext;
+  };
+
+  beforeEach(async () => {
+    tmpDir = await fse.realpath(await fse.mkdtemp(path.join(os.tmpdir(), 'teamai-cursor-user-rules-')));
+    home = path.join(tmpDir, 'home');
+    vi.stubEnv('HOME', home);
+    vi.stubEnv('USERPROFILE', home);
+    userRepo = path.join(tmpDir, 'user-team-repo');
+    await fse.outputFile(path.join(userRepo, 'teamai.yaml'), 'team: test\nrepo: https://example.invalid/x/team.git\n');
+    await fse.outputFile(path.join(userRepo, 'rules', 'codeword.md'), 'The team codeword is PELICAN-42.\n');
+    await fse.outputFile(path.join(userRepo, 'rules', 'scoped.md'), '---\npaths:\n  - "src/**"\n---\nPrefer named exports.\n');
+    await fse.outputFile(
+      path.join(home, '.teamai', 'config.yaml'),
+      `repo:\n  localPath: ${userRepo}\n  remote: https://example.invalid/x/team.git\nusername: u\n`,
+    );
+    await fse.ensureDir(path.join(home, '.cursor', 'rules'));
+    userConfig = {
+      repo: { localPath: userRepo, remote: 'https://example.invalid/x/team.git' },
+      username: 'u',
+      additionalRoles: [],
+      scope: 'user',
+    } as unknown as LocalConfig;
+  });
+
+  afterEach(async () => {
+    vi.unstubAllEnvs();
+    await fse.remove(tmpDir);
+  });
+
+  it('adds the user rules when the workspace is outside the home directory, a path-scoped rule after its globs', async () => {
+    const workspace = path.join(tmpDir, 'work', 'project');
+    await fse.ensureDir(workspace);
+
+    const text = await context(workspace);
+
+    expect(text).toContain('The team codeword is PELICAN-42.');
+    expect(text).toContain('Applies to files matching: src/**\nPrefer named exports.');
+    expect(text).not.toContain('paths:');
+  });
+
+  it('adds the user-scope culture and shared instructions, which ~/.cursor/rules also holds', async () => {
+    await fse.outputFile(path.join(userRepo, 'culture.md'), '---\ncompany:\n  name: Acme\n---\n\nBe kind to teammates.\n');
+    await fse.outputFile(path.join(userRepo, 'claudemd', 'shared.md'), 'Shared team instructions.\n');
+
+    const text = (await context(path.join(tmpDir, 'work')))!;
+
+    expect(text).toContain('Be kind to teammates.');
+    expect(text).toContain('Shared team instructions.');
+    expect(text).toContain('PELICAN-42');
+    expect(text).not.toContain('<!--');
+  });
+
+  it('adds nothing under the home directory, where Cursor loads ~/.cursor/rules itself', async () => {
+    const workspace = path.join(home, 'src', 'project');
+    await fse.ensureDir(workspace);
+
+    expect(await context(workspace)).toBeNull();
+  });
+
+  it('adds nothing when a link on the walk already points at ~/.cursor/rules', async () => {
+    const workspace = path.join(tmpDir, 'work', 'project');
+    await fse.ensureDir(path.join(tmpDir, 'work', '.cursor'));
+    await fse.symlink(path.join(home, '.cursor', 'rules'), path.join(tmpDir, 'work', '.cursor', 'rules'), 'junction');
+    await fse.ensureDir(workspace);
+
+    expect(await context(workspace)).toBeNull();
+  });
+
+  it('adds the user rules, not the project\'s, in a teamai project outside the home directory', async () => {
+    const projectRepo = path.join(tmpDir, 'project-team-repo');
+    await fse.outputFile(path.join(projectRepo, 'teamai.yaml'), 'team: proj\nrepo: https://example.invalid/x/proj.git\n');
+    await fse.outputFile(path.join(projectRepo, 'rules', 'project.md'), 'The project codeword is HERON-7.\n');
+    const projectRoot = path.join(tmpDir, 'work', 'project');
+    await fse.ensureDir(projectRoot);
+    const projectConfig = {
+      repo: { localPath: projectRepo, remote: 'https://example.invalid/x/proj.git' },
+      username: 'u',
+      additionalRoles: [],
+      scope: 'project',
+      projectRoot,
+    } as unknown as LocalConfig;
+
+    const text = await context(projectRoot, 'cursor', projectConfig);
+
+    expect(text).toContain('PELICAN-42');
+    expect(text).not.toContain('HERON-7');
+  });
+
+  it('adds nothing for a tool other than Cursor, or when Cursor is excluded from the user scope', async () => {
+    const workspace = path.join(tmpDir, 'work');
+    await fse.ensureDir(workspace);
+
+    expect(await context(workspace, 'claude')).toBeNull();
+    expect(await context(workspace, 'cursor', { ...userConfig, disabledAgents: ['cursor'] } as LocalConfig)).toBeNull();
+  });
+
+  it('adds nothing when the text is over Cursor\'s limit, which would drop the whole hook reply', async () => {
+    await fse.outputFile(path.join(userRepo, 'rules', 'long.md'), `${'x'.repeat(10_000)}\n`);
+    const workspace = path.join(tmpDir, 'work');
+    await fse.ensureDir(workspace);
+
+    expect(await context(workspace)).toBeNull();
+  });
+});
@@ -588,6 +588,107 @@ describe('doctor — rules delivered on disk', () => {
     expect(await namedCheck('Team rules are inlined in Hermes SOUL.md')).toBeUndefined();
   });
 
+  describe('Cursor workspaces outside the home directory (#1197)', () => {
+    const CURSOR_HOOKS = '.cursor/hooks.json';
+    const OUTSIDE_HOME = 'Team rules reach Cursor workspaces outside the home directory';
+    const WITH_ENV_HINT = 'Team rules and the team env hint fit one Cursor hook reply';
+
+    async function writeCursorHooks(sessionStart: unknown[]): Promise<void> {
+      await fse.outputFile(path.join(homeDir, CURSOR_HOOKS), JSON.stringify({ version: 1, hooks: { sessionStart } }));
+    }
+
+    beforeEach(() => {
+      teamConfig.toolPaths.cursor = { rules: CURSOR_RULES, settings: CURSOR_HOOKS };
+    });
+
+    it('passes when ~/.cursor/hooks.json registers the teamai sessionStart hook', async () => {
+      await writeCursorHooks([{ command: 'bash -lc "teamai hook-dispatch session-start --tool cursor 2>/dev/null" || true' }]);
+
+      expect(await (await namedCheck(OUTSIDE_HOME))!.check()).toBe(true);
+    });
+
+    it('fails when no teamai sessionStart hook is registered, saying why the rules file is not enough', async () => {
+      await writeCursorHooks([]);
+
+      const check = (await namedCheck(OUTSIDE_HOME))!;
+      expect(await check.check()).toBe(false);
+      expect(check.fix).toContain('only in a workspace under the home directory');
+      expect(check.fix).toContain('teamai hooks inject');
+    });
+
+    it.each([
+      ['teamai hook-dispatch session-start --tool claude', false],
+      ['teamai hook-dispatch session-start --tool cursor-agent', false],
+      ['teamai hook-dispatch session-start --tool=cursor', true],
+    ])('reads the dispatch\'s --tool value: %s', async (command, passes) => {
+      await writeCursorHooks([{ command }]);
+
+      expect(await (await namedCheck(OUTSIDE_HOME))!.check()).toBe(passes);
+    });
+
+    it('passes near the limit when nothing else shares the hook reply', async () => {
+      await fse.writeFile(path.join(repoPath, 'rules', 'long.md'), `${'x'.repeat(9_500)}\n`);
+      await writeCursorHooks([{ command: 'teamai hook-dispatch session-start --tool cursor' }]);
+
+      expect(await (await namedCheck(OUTSIDE_HOME))!.check()).toBe(true);
+      expect(await (await namedCheck(WITH_ENV_HINT))!.check()).toBe(true);
+    });
+
+    it('flags the team env hint pushing the rules out of the shared hook reply', async () => {
+      await fse.writeFile(path.join(repoPath, 'rules', 'long.md'), `${'x'.repeat(9_800)}\n`);
+      await fse.outputFile(path.join(repoPath, 'env', 'env.yaml'), 'variables:\n  - key: API_URL\n    value: https://example.invalid\n');
+      await writeCursorHooks([{ command: 'teamai hook-dispatch session-start --tool cursor' }]);
+
+      expect(await (await namedCheck(OUTSIDE_HOME))!.check()).toBe(true);
+      const shared = (await namedCheck(WITH_ENV_HINT))!;
+      expect(shared.informational).toBe(true);
+      expect(await shared.check()).toBe(false);
+      expect(shared.fix).toContain('leaves the rules out');
+    });
+
+    it('names the length, not the team\'s builtin.disabled entry, while the hook is still registered', async () => {
+      await fse.outputFile(path.join(repoPath, 'hooks', 'hooks.yaml'), 'builtin:\n  disabled:\n    - Hook dispatch session-start\n');
+      await fse.writeFile(path.join(repoPath, 'rules', 'long.md'), `${'x'.repeat(10_000)}\n`);
+      await writeCursorHooks([{ command: 'teamai hook-dispatch session-start --tool cursor' }]);
+
+      const check = (await namedCheck(OUTSIDE_HOME))!;
+      expect(check.fix).not.toContain('builtin.disabled');
+      expect(check.fix).toContain('characters');
+    });
+
+    it('tells the member to repair invalid JSON by hand, which hooks inject will not rewrite', async () => {
+      await fse.outputFile(path.join(homeDir, CURSOR_HOOKS), '{ invalid JSON');
+
+      const check = (await namedCheck(OUTSIDE_HOME))!;
+      expect(await check.check()).toBe(false);
+      expect(check.fix).toContain('Fix the file by hand');
+    });
+
+    it('names the team\'s builtin.disabled entry when the team turned the session-start hook off', async () => {
+      await fse.outputFile(path.join(repoPath, 'hooks', 'hooks.yaml'), 'builtin:\n  disabled:\n    - Hook dispatch session-start\n');
+      await writeCursorHooks([]);
+
+      const check = (await namedCheck(OUTSIDE_HOME))!;
+      expect(await check.check()).toBe(false);
+      expect(check.fix).toContain('builtin.disabled');
+    });
+
+    it('fails when the rules are over Cursor\'s hook context limit', async () => {
+      await fse.writeFile(path.join(repoPath, 'rules', 'long.md'), `${'x'.repeat(10_000)}\n`);
+      await writeCursorHooks([{ command: 'teamai hook-dispatch session-start --tool cursor' }]);
+
+      const check = (await namedCheck(OUTSIDE_HOME))!;
+      expect(await check.check()).toBe(false);
+      expect(check.fix).toContain('10000-character limit');
+    });
+
+    it('emits no check in project scope, where the project delivers into the workspace itself', async () => {
+      Object.assign(localConfig, { scope: 'project', projectRoot: path.join(tempDir, 'project') });
+
+      expect(await namedCheck(OUTSIDE_HOME)).toBeUndefined();
+    });
+  });
+
   describe('Hermes in project scope (#946)', () => {
     beforeEach(async () => {
       const hermesHome = path.join(tempDir, 'hermes');
 
@@ -23,6 +23,12 @@ describe('resolveHookCwd', () => {
     })).toBe('/project');
   });
 
+  it('turns a Windows workspace root sent as a URI path (/c:/...) into a drive path', () => {
+    // The Cursor IDE sends `folders.map((f) => f.uri.path)`, which keeps the URI's leading slash.
+    expect(resolveHookCwd({ workspace_roots: ['/c:/Users/me/project'] })).toBe('c:/Users/me/project');
+    expect(resolveHookCwd({ cwd: '/D:/work' })).toBe('D:/work');
+  });
+
   it('skips blank workspace_roots entries', () => {
     expect(resolveHookCwd({
       workspace_roots: ['', '  ', '/real-root'],
 
@@ -185,6 +185,46 @@ describe('hook-dispatch', () => {
       expect(result.output).toBeNull();
     });
 
+    it('drops a yielding handler\'s context when the merged reply is over Cursor\'s limit, keeping the rest (#1197)', async () => {
+      const context = (text: string) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: text } });
+      const rules = createHandler('cursor-user-rules', context('R'.repeat(9_990)));
+      const env = createHandler('team-env-hint', context('Team env variables in this scope: API_URL.'));
+      const dispatcher = createDispatcher({ localConfig: null, handlers: [
+        { event: 'session-start', matcher: '*', handler: rules, yieldsToContextLimit: true },
+        { event: 'session-start', matcher: '*', handler: env },
+      ] });
+
+      const overCursor = await dispatcher.dispatch('session-start', '*', {}, 'cursor');
+      const claude = await dispatcher.dispatch('session-start', '*', {}, 'claude');
+
+      expect(JSON.parse(overCursor.output!).hookSpecificOutput.additionalContext).toBe('Team env variables in this scope: API_URL.');
+      expect(JSON.parse(claude.output!).hookSpecificOutput.additionalContext).toContain('R'.repeat(9_990));
+    });
+
+    it('keeps a yielding handler\'s context when the others alone are still over Cursor\'s limit', async () => {
+      const context = (text: string) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: text } });
+      const dispatcher = createDispatcher({ localConfig: null, handlers: [
+        { event: 'session-start', matcher: '*', handler: createHandler('cursor-user-rules', context('RULES')), yieldsToContextLimit: true },
+        { event: 'session-start', matcher: '*', handler: createHandler('mr-hint', context('M'.repeat(10_200))) },
+      ] });
+
+      const result = await dispatcher.dispatch('session-start', '*', {}, 'cursor');
+
+      expect(JSON.parse(result.output!).hookSpecificOutput.additionalContext).toContain('RULES');
+    });
+
+    it('keeps a yielding handler\'s context when the merged reply fits Cursor\'s limit', async () => {
+      const context = (text: string) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: text } });
+      const dispatcher = createDispatcher({ localConfig: null, handlers: [
+        { event: 'session-start', matcher: '*', handler: createHandler('cursor-user-rules', context('RULES')), yieldsToContextLimit: true },
+        { event: 'session-start', matcher: '*', handler: createHandler('team-env-hint', context('ENV')) },
+      ] });
+
+      const result = await dispatcher.dispatch('session-start', '*', {}, 'cursor');
+
+      expect(JSON.parse(result.output!).hookSpecificOutput.additionalContext).toBe('RULES\nENV');
+    });
+
     it('merges additionalContext from concurrent handlers', async () => {
       const first = createHandler('votes', JSON.stringify({
         hookSpecificOutput: { hookEventName: 'Stop', additionalContext: 'VOTES' },
 
@@ -0,0 +1,70 @@
+/**
+ * Cursor's user-scope rules outside the home directory (#1197).
+ *
+ * Cursor (IDE and CLI) has no direct read of `~/.cursor/rules`. It walks up
+ * from the workspace root and loads `<ancestor>/.cursor/rules` at each step
+ * (`LocalCursorRulesService.loadRulesFromDirAndAncestors`), so the file a
+ * user-scope pull writes reaches only a workspace under the home directory.
+ * Anywhere else, teamai's sessionStart hook adds the same rules and
+ * instruction blocks; under the home directory it adds nothing, since the
+ * walk already loads the files.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadLocalConfig, loadTeamConfig } from './config.js';
+import { CURSOR_HOOK_CONTEXT_LIMIT } from './hook-dispatch.js';
+import { instructionHookTextFor } from './instruction-targets.js';
+import { teamRulesContext } from './resources/rules.js';
+import { isAgentExcluded, resolveToolBaseDir, scopedToolPaths, type LocalConfig, type TeamaiConfig } from './types.js';
+import { log } from './utils/logger.js';
+
+async function canonicalPath(p: string): Promise<string> {
+  const resolved = await fs.promises.realpath(p).catch(() => path.resolve(p));
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+/** Whether Cursor's walk up from `workspace` reaches `rulesDir`, directly or through a link on the way. */
+async function cursorWalkReaches(workspace: string, rulesDir: string): Promise<boolean> {
+  const target = await canonicalPath(rulesDir);
+  let dir = path.resolve(workspace);
+  for (;;) {
+    if (await canonicalPath(path.join(dir, '.cursor', 'rules')) === target) return true;
+    const parent = path.dirname(dir);
+    if (parent === dir) return false;
+    dir = parent;
+  }
+}
+
+/** The user-scope rules directory a pull writes Cursor's rules to, or undefined when Cursor gets none. */
+export function cursorUserRulesDir(teamConfig: TeamaiConfig, userConfig: LocalConfig): string | undefined {
+  const rules = scopedToolPaths(teamConfig, userConfig).cursor?.rules;
+  return rules === undefined ? undefined : path.join(resolveToolBaseDir('cursor', userConfig), rules);
+}
+
+/** The user-scope instruction blocks and team rules, as the hook adds them; null when there are none. */
+export async function cursorUserRulesText(teamConfig: TeamaiConfig, userConfig: LocalConfig): Promise<string | null> {
+  const parts = [await instructionHookTextFor(teamConfig, userConfig, 'cursor'), await teamRulesContext(teamConfig, userConfig)]
+    .filter((part): part is string => !!part);
+  return parts.length === 0 ? null : parts.join('\n\n');
+}
+
+/**
+ * What the sessionStart hook adds for a Cursor session in `workspace`: the
+ * user-scope rules when the walk does not reach their directory, else null.
+ * `config` is the scope the hook resolved for the workspace; a project there
+ * delivers its own rules into the workspace, so the user scope is loaded apart.
+ */
+export async function cursorUserRulesContext(workspace: string, config: LocalConfig): Promise<string | null> {
+  const userConfig = config.scope === 'user' ? config : await loadLocalConfig();
+  if (!userConfig || isAgentExcluded(userConfig, 'cursor')) return null;
+  const teamConfig = await loadTeamConfig(userConfig.repo.localPath);
+  if (!teamConfig) return null;
+  const rulesDir = cursorUserRulesDir(teamConfig, userConfig);
+  if (rulesDir === undefined || await cursorWalkReaches(workspace, rulesDir)) return null;
+  const text = await cursorUserRulesText(teamConfig, userConfig);
+  if (text !== null && text.length > CURSOR_HOOK_CONTEXT_LIMIT) {
+    log.debug(`cursor-user-rules: ${text.length} characters, over Cursor's ${CURSOR_HOOK_CONTEXT_LIMIT}-character hook limit; not added`);
+    return null;
+  }
+  return text;
+}