agentic-workflow-manager 9.14.1 → 9.15.0

package/dist/src/core/init/migrate-cursor-mdc.js

@@ -0,0 +1,72 @@
+"use strict";
+// cli/src/core/init/migrate-cursor-mdc.ts
+//
+// Plan B S3 / R8: after Cursor skills move to link under ~/.agents/skills, remove
+// only artifact-state records that were rendered with cursor-mdc under Cursor rules
+// dirs. Never touch unrecorded files; never remove awm.mdc (project guidance carrier).
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateCursorMdcSkills = migrateCursorMdcSkills;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../paths");
+const artifact_state_1 = require("../artifact-state");
+function isUnderCursorRules(targetPath, projectRoot) {
+    const resolved = path_1.default.resolve(targetPath);
+    const globalRules = path_1.default.resolve((0, paths_1.homeDir)(), '.cursor', 'rules');
+    if (resolved === globalRules || resolved.startsWith(globalRules + path_1.default.sep))
+        return true;
+    if (!projectRoot)
+        return false;
+    const localRules = path_1.default.resolve(projectRoot, '.cursor', 'rules');
+    return resolved === localRules || resolved.startsWith(localRules + path_1.default.sep);
+}
+function isAwmMdcCarrier(record) {
+    return record.name === 'awm' || path_1.default.basename(record.targetPath) === 'awm.mdc';
+}
+function safeUnlinkManaged(targetPath) {
+    try {
+        const stat = fs_1.default.lstatSync(targetPath);
+        if (!stat.isFile() || stat.isSymbolicLink())
+            return false;
+        fs_1.default.unlinkSync(targetPath);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    }
+}
+/**
+ * Drop historical cursor-mdc skill renders under Cursor rules dirs once link
+ * skills are the delivery path. Idempotent; safe on machines without cursor.
+ */
+function migrateCursorMdcSkills(opts) {
+    const stateFile = opts.stateFile ?? (0, artifact_state_1.artifactStateFile)();
+    const existing = (0, artifact_state_1.readArtifactState)(stateFile);
+    const removed = [];
+    const kept = [];
+    for (const record of existing) {
+        if (record.renderer !== 'cursor-mdc') {
+            kept.push(record);
+            continue;
+        }
+        if (isAwmMdcCarrier(record)) {
+            kept.push(record);
+            continue;
+        }
+        if (!isUnderCursorRules(record.targetPath, opts.projectRoot)) {
+            kept.push(record);
+            continue;
+        }
+        safeUnlinkManaged(record.targetPath);
+        removed.push(record.targetPath);
+    }
+    if (removed.length > 0) {
+        (0, artifact_state_1.writeArtifactState)(kept, stateFile);
+    }
+    return { removed, kept: kept.length };
+}

package/dist/src/core/init/steps.js

@@ -35,6 +35,7 @@ const skill_integrity_1 = require("../skill-integrity");
 const registries_2 = require("../registries");
 const project_constitution_inject_1 = require("../context/project-constitution-inject");
 const codex_agents_1 = require("../context/strategies/codex-agents");
+const migrate_cursor_mdc_1 = require("./migrate-cursor-mdc");
 // ---------------------------------------------------------------------------
 // defaultActions — bridges the real functions to the InitActions interface
 // ---------------------------------------------------------------------------
@@ -231,6 +232,9 @@ function stepDevCore(d) {
             ...(localOnly ? { scopeOverride: 'local' } : {}),
         });
     }
+    if (d.enabledAgents.includes('cursor') || d.agent === 'cursor') {
+        (0, migrate_cursor_mdc_1.migrateCursorMdcSkills)({ projectRoot: d.ctx.project?.root ?? d.cwd });
+    }
     return ok('machine.devCore', 'machine', 'applied', localOnly ? 'installed at project scope (no global skill dir)' : undefined);
 }
 /** Step 3.5 – Repair broken global skill symlinks (orphans outside the baseline). */

package/dist/src/providers/index.js

@@ -163,13 +163,27 @@ function providers() {
         cursor: {
             label: 'Cursor',
             configHome: configHomeFor('cursor'),
+            // Skills join the Codex/OpenCode shared physical dirs (~/.agents/skills +
+            // .agents/skills, renderer link). cursor-mdc remains registered for S3
+            // migration reads of historical ~/.cursor/rules installs.
             skill: {
-                global: path_1.default.join(root('cursor'), 'rules'),
-                local: '.cursor/rules',
-                renderer: 'cursor-mdc',
+                global: path_1.default.join(home, '.agents/skills'),
+                local: '.agents/skills',
+                renderer: 'link',
             },
             workflow: null,
-            agent: null,
+            agent: {
+                global: path_1.default.join(root('cursor'), 'agents'),
+                local: '.cursor/agents',
+                renderer: 'link',
+            },
+            hooks: {
+                type: 'cursor-hooks-json',
+                settingsPath: path_1.default.join(root('cursor'), 'hooks.json'),
+                scriptsDir: path_1.default.join(awm, 'hooks/cursor'),
+                matcher: '',
+                eventName: '',
+            },
             injection: {
                 type: 'managed-agents-md',
                 // Cursor has no confirmed user-level/global AGENTS.md-equivalent file — its

package/dist/tests/commands/add.test.js

@@ -65,18 +65,16 @@ function makeProjectRoot() {
     fs_1.default.writeFileSync(path_1.default.join(projectRoot, 'package.json'), JSON.stringify({ name: 'fixture' }));
     return projectRoot;
 }
-it('awm add demo materializes a real Cursor .mdc file end-to-end', () => {
+it('awm add demo materializes a Cursor skill link under .agents/skills end-to-end', () => {
     const content = makeContentFixture();
     const projectRoot = makeProjectRoot();
     const bundles = (0, bundles_1.discoverBundles)(content);
     const outcome = (0, add_1.runAddBundleCore)({ name: 'demo', agent: 'cursor', cwd: projectRoot }, prefsFor('cursor'), bundles);
     expect(outcome.code).toBe(0);
-    const mdcPath = path_1.default.join(projectRoot, '.cursor/rules/demo-skill.mdc');
-    expect(fs_1.default.existsSync(mdcPath)).toBe(true);
-    const rendered = fs_1.default.readFileSync(mdcPath, 'utf8');
-    expect(rendered).toContain('description: A demo skill for add.test.ts e2e');
-    expect(rendered).toContain('alwaysApply: false');
-    expect(rendered).toContain('Follow the demo skill body.');
+    const linked = path_1.default.join(projectRoot, '.agents/skills/demo-skill');
+    expect(fs_1.default.existsSync(path_1.default.join(projectRoot, '.cursor/rules/demo-skill.mdc'))).toBe(false);
+    expect(fs_1.default.lstatSync(linked).isSymbolicLink() || fs_1.default.existsSync(path_1.default.join(linked, 'SKILL.md'))).toBe(true);
+    expect(fs_1.default.readFileSync(path_1.default.join(linked, 'SKILL.md'), 'utf8')).toContain('Follow the demo skill body.');
     fs_1.default.rmSync(content, { recursive: true, force: true });
     fs_1.default.rmSync(projectRoot, { recursive: true, force: true });
 });

package/dist/tests/commands/context-budget/budget.test.js

@@ -134,3 +134,71 @@ describe('pinning refuses to happen when there is nothing to measure', () => {
         expect(fs_1.default.existsSync(path_1.default.join(cwd, budget_1.CONFIG_FILE))).toBe(true);
     });
 });
+describe('Cursor hook budget pins (Plan B R5)', () => {
+    let tmpHome;
+    let originalHome;
+    let originalAwmHome;
+    const dirs = [];
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-cursor-budget-home-'));
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        dirs.forEach((d) => fs_1.default.rmSync(d, { recursive: true, force: true }));
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    it('skips cursor pins when hooks are not installed', () => {
+        const { checkBudget } = require('../../../src/commands/context-budget/budget');
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-budget-'));
+        dirs.push(dir);
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'AGENTS.md'), 'a'.repeat(100));
+        const report = checkBudget(dir);
+        expect(report.cursorHooks).toBeUndefined();
+        expect(report.status).toBe('pinned');
+    });
+    it('marks over when installed script caps exceed pin or disagree with module constants', () => {
+        const { checkBudget, writeConfig } = require('../../../src/commands/context-budget/budget');
+        const { CURSOR_SESSION_START_MAX_BYTES, CURSOR_REANCHOR_MAX_BYTES, } = require('../../../src/core/cursor-budgets');
+        expect(CURSOR_SESSION_START_MAX_BYTES).toBe(24 * 1024);
+        expect(CURSOR_REANCHOR_MAX_BYTES).toBe(4 * 1024);
+        const scripts = path_1.default.join(tmpHome, '.awm/hooks/cursor');
+        fs_1.default.mkdirSync(scripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(scripts, 'session-start'), 'const MAX_SESSION_BYTES = 24 * 1024;\nconst MAX_REANCHOR_BYTES = 4 * 1024;\n');
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-budget-'));
+        dirs.push(dir);
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'AGENTS.md'), 'a'.repeat(100));
+        writeConfig(dir, {
+            files: ['AGENTS.md'],
+            maxBytes: 1000,
+            'cursor.sessionStartMaxBytes': 1024, // below observed 24KiB
+            'cursor.reanchorMaxBytes': 4096,
+        });
+        const report = checkBudget(dir);
+        expect(report.cursorHooks?.status).toBe('over');
+        expect(report.status).toBe('over');
+    });
+    it('is within when script literals match defaults', () => {
+        const { checkBudget } = require('../../../src/commands/context-budget/budget');
+        const scripts = path_1.default.join(tmpHome, '.awm/hooks/cursor');
+        fs_1.default.mkdirSync(scripts, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(scripts, 'session-start'), 'const MAX_SESSION_BYTES = 24 * 1024;\nconst MAX_REANCHOR_BYTES = 4 * 1024;\n');
+        const dir = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-budget-'));
+        dirs.push(dir);
+        fs_1.default.writeFileSync(path_1.default.join(dir, 'AGENTS.md'), 'a'.repeat(100));
+        const report = checkBudget(dir);
+        expect(report.cursorHooks?.status).toBe('within');
+        expect(report.cursorHooks?.observedSessionStartMaxBytes).toBe(24 * 1024);
+    });
+});

package/dist/tests/commands/doctor.test.js

@@ -229,13 +229,13 @@ describe('renderProviderReport — capability tier (Task 4.4)', () => {
             overall: 'healthy',
             providers: [
                 { id: 'claude-code', label: 'Claude Code', tier: 'hooks-native', checks: [] },
-                { id: 'cursor', label: 'Cursor', tier: 'agents-md-managed', checks: [] },
+                { id: 'cursor', label: 'Cursor', tier: 'hooks-native', checks: [] },
                 { id: 'antigravity', label: 'Antigravity', tier: 'context-only', checks: [] },
             ],
         };
         const out = (0, doctor_1.renderProviderReport)(report);
         expect(out).toContain('Provider: Claude Code (hooks-native)');
-        expect(out).toContain('Provider: Cursor (agents-md-managed)');
+        expect(out).toContain('Provider: Cursor (hooks-native)');
         expect(out).toContain('Provider: Antigravity (context-only)');
     });
 });

package/dist/tests/commands/hooks/cursor.test.js

@@ -0,0 +1,257 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const crypto_1 = __importDefault(require("crypto"));
+describe('installHook / computeHookStatus / uninstallHook — Cursor adapter', () => {
+    let tmpHome;
+    let tmpRegistry;
+    let hooksJson;
+    let cursorScriptsDir;
+    let originalHome;
+    let originalAwmHome;
+    beforeEach(() => {
+        tmpHome = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-cursor-hooks-'));
+        tmpRegistry = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-cursor-registry-'));
+        hooksJson = path_1.default.join(tmpHome, '.cursor/hooks.json');
+        cursorScriptsDir = path_1.default.join(tmpHome, '.awm/hooks/cursor');
+        originalHome = process.env.HOME;
+        originalAwmHome = process.env.AWM_HOME;
+        process.env.HOME = tmpHome;
+        process.env.AWM_HOME = path_1.default.join(tmpHome, '.awm');
+        jest.resetModules();
+    });
+    afterEach(() => {
+        fs_1.default.rmSync(tmpHome, { recursive: true, force: true });
+        fs_1.default.rmSync(tmpRegistry, { recursive: true, force: true });
+        if (originalHome === undefined)
+            delete process.env.HOME;
+        else
+            process.env.HOME = originalHome;
+        if (originalAwmHome === undefined)
+            delete process.env.AWM_HOME;
+        else
+            process.env.AWM_HOME = originalAwmHome;
+    });
+    function writeRegistry(content = '#!/usr/bin/env node\nconsole.log("{}")') {
+        const regHooks = path_1.default.join(tmpRegistry, 'hooks');
+        const regSkill = path_1.default.join(tmpRegistry, 'skills/using-awm');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.mkdirSync(regSkill, { recursive: true });
+        for (const name of ['cursor-session-start', 'cursor-pre-compact', 'cursor-post-tool-use']) {
+            fs_1.default.writeFileSync(path_1.default.join(regHooks, name), content, { mode: 0o755 });
+        }
+        fs_1.default.writeFileSync(path_1.default.join(regSkill, 'SKILL.md'), '---\nname: using-awm\n---\nMUST invoke skills.\n');
+    }
+    function installOpts(over = {}) {
+        return {
+            agent: 'cursor',
+            registryRoot: tmpRegistry,
+            installMethod: 'copy',
+            baselineRegistryVersion: '4.9.0',
+            ...over,
+        };
+    }
+    function awmEntries() {
+        return {
+            sessionStart: [{ command: path_1.default.join(cursorScriptsDir, 'session-start') }],
+            preCompact: [{ command: path_1.default.join(cursorScriptsDir, 'pre-compact') }],
+            postToolUse: [{ command: path_1.default.join(cursorScriptsDir, 'post-tool-use') }],
+        };
+    }
+    it('merges three AWM events and preserves non-AWM entries', () => {
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({
+            version: 1,
+            hooks: {
+                sessionStart: [{ command: '/user/custom-start' }],
+                stop: [{ command: 'echo stop' }],
+            },
+        }));
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook(installOpts());
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg.version).toBe(1);
+        expect(cfg.hooks.stop).toEqual([{ command: 'echo stop' }]);
+        expect(cfg.hooks.sessionStart).toEqual([
+            { command: '/user/custom-start' },
+            { command: path_1.default.join(cursorScriptsDir, 'session-start') },
+        ]);
+        expect(cfg.hooks.preCompact).toEqual([{ command: path_1.default.join(cursorScriptsDir, 'pre-compact') }]);
+        expect(cfg.hooks.postToolUse).toEqual([{ command: path_1.default.join(cursorScriptsDir, 'post-tool-use') }]);
+        expect(fs_1.default.existsSync(path_1.default.join(cursorScriptsDir, 'session-start'))).toBe(true);
+        expect(fs_1.default.readFileSync(path_1.default.join(cursorScriptsDir, 'using-awm.md'), 'utf8')).toContain('MUST invoke skills.');
+    });
+    it('installs cleanly with no pre-existing hooks.json and backs up on replace', () => {
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const first = installHook(installOpts({ installMethod: 'symlink' }));
+        expect(first.status).toBe('installed');
+        expect(first.backupPath).toBeNull();
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg).toEqual({ version: 1, hooks: awmEntries() });
+        expect(fs_1.default.lstatSync(path_1.default.join(cursorScriptsDir, 'session-start')).isSymbolicLink()).toBe(true);
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({ version: 1, hooks: { sessionStart: [] } }, null, 2));
+        const second = installHook(installOpts());
+        expect(second.status).toBe('installed');
+        expect(second.backupPath).toMatch(/hooks\.json\..*\.bak$/);
+    });
+    it('fails when registry lacks cursor-session-start', () => {
+        const regHooks = path_1.default.join(tmpRegistry, 'hooks');
+        fs_1.default.mkdirSync(regHooks, { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'cursor-pre-compact'), 'x', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(regHooks, 'cursor-post-tool-use'), 'x', { mode: 0o755 });
+        fs_1.default.mkdirSync(path_1.default.join(tmpRegistry, 'skills/using-awm'), { recursive: true });
+        fs_1.default.writeFileSync(path_1.default.join(tmpRegistry, 'skills/using-awm/SKILL.md'), '---\nname: using-awm\n---\n');
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook(installOpts())).toThrow(/Cursor hook source missing/);
+        expect(fs_1.default.existsSync(hooksJson)).toBe(false);
+    });
+    it('refuses invalid JSON, unknown version, and duplicate AWM entries without writing', () => {
+        writeRegistry();
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, '{not json');
+        const beforeBad = fs_1.default.readFileSync(hooksJson, 'utf8');
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook(installOpts())).toThrow(/not valid JSON/);
+        expect(fs_1.default.readFileSync(hooksJson, 'utf8')).toBe(beforeBad);
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({ version: 2, hooks: {} }));
+        const beforeVer = fs_1.default.readFileSync(hooksJson, 'utf8');
+        expect(() => installHook(installOpts())).toThrow(/unsupported hooks\.json version/);
+        expect(fs_1.default.readFileSync(hooksJson, 'utf8')).toBe(beforeVer);
+        const dup = {
+            version: 1,
+            hooks: {
+                sessionStart: [
+                    { command: path_1.default.join(cursorScriptsDir, 'session-start') },
+                    { command: path_1.default.join(cursorScriptsDir, 'session-start') },
+                ],
+            },
+        };
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify(dup, null, 2));
+        const beforeDup = fs_1.default.readFileSync(hooksJson, 'utf8');
+        expect(() => installHook(installOpts())).toThrow(/multiple AWM sessionStart/);
+        expect(fs_1.default.readFileSync(hooksJson, 'utf8')).toBe(beforeDup);
+        expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/backups'))).toBe(false);
+    });
+    it('aborts when an event key is present but not an array', () => {
+        writeRegistry();
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({ version: 1, hooks: { sessionStart: { command: 'x' } } }));
+        const before = fs_1.default.readFileSync(hooksJson, 'utf8');
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook(installOpts())).toThrow(/must be an array/);
+        expect(fs_1.default.readFileSync(hooksJson, 'utf8')).toBe(before);
+    });
+    it('prunes dead AWM entries from another AWM_HOME and preserves live parallels', () => {
+        writeRegistry();
+        const dead = '/tmp/awm-gone-never/hooks/cursor/session-start';
+        const liveOther = path_1.default.join(tmpHome, '.awm-other/hooks/cursor/session-start');
+        fs_1.default.mkdirSync(path_1.default.dirname(liveOther), { recursive: true });
+        fs_1.default.writeFileSync(liveOther, '#!/usr/bin/env node\n', { mode: 0o755 });
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({
+            version: 1,
+            hooks: {
+                sessionStart: [
+                    { command: dead },
+                    { command: liveOther },
+                ],
+            },
+        }, null, 2));
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook(installOpts());
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg.hooks.sessionStart.map((e) => e.command)).toEqual([
+            liveOther,
+            path_1.default.join(cursorScriptsDir, 'session-start'),
+        ]);
+    });
+    it('is idempotent when nothing changed', () => {
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const first = installHook(installOpts());
+        expect(first.status).toBe('installed');
+        const contentBefore = fs_1.default.readFileSync(hooksJson, 'utf8');
+        const mtimeBefore = fs_1.default.statSync(hooksJson).mtimeMs;
+        const second = installHook(installOpts());
+        expect(second.status).toBe('already-up-to-date');
+        expect(second.backupPath).toBeNull();
+        expect(fs_1.default.readFileSync(hooksJson, 'utf8')).toBe(contentBefore);
+        expect(fs_1.default.statSync(hooksJson).mtimeMs).toBe(mtimeBefore);
+    });
+    it.each([
+        [false, 'pending-first-run'],
+        [true, 'healthy'],
+    ])('derives trust from heartbeat (present=%s → %s)', (heartbeat, expected) => {
+        fs_1.default.mkdirSync(cursorScriptsDir, { recursive: true });
+        const scriptPath = path_1.default.join(cursorScriptsDir, 'session-start');
+        fs_1.default.writeFileSync(scriptPath, '#!/usr/bin/env node\n', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(cursorScriptsDir, 'using-awm.md'), '# using-awm\n');
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({ version: 1, hooks: awmEntries() }, null, 2));
+        if (heartbeat) {
+            fs_1.default.writeFileSync(path_1.default.join(cursorScriptsDir, 'heartbeat.json'), JSON.stringify({ hash: crypto_1.default.createHash('sha256').update(fs_1.default.readFileSync(scriptPath)).digest('hex') }));
+        }
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        expect(computeHookStatus('cursor').trust).toBe(expected);
+    });
+    it('reports stale trust when heartbeat hash mismatches', () => {
+        fs_1.default.mkdirSync(cursorScriptsDir, { recursive: true });
+        const scriptPath = path_1.default.join(cursorScriptsDir, 'session-start');
+        fs_1.default.writeFileSync(scriptPath, '#!/usr/bin/env node\n', { mode: 0o755 });
+        fs_1.default.writeFileSync(path_1.default.join(cursorScriptsDir, 'using-awm.md'), '# using-awm\n');
+        fs_1.default.writeFileSync(path_1.default.join(cursorScriptsDir, 'heartbeat.json'), JSON.stringify({ hash: 'deadbeef' }));
+        fs_1.default.mkdirSync(path_1.default.dirname(hooksJson), { recursive: true });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify({ version: 1, hooks: awmEntries() }, null, 2));
+        const { computeHookStatus } = require('../../../src/commands/hooks/status');
+        const status = computeHookStatus('cursor');
+        expect(status.trust).toBe('stale');
+        expect(status.overall).toBe('DEGRADED');
+    });
+    it('refuses install when baseline registry is below 4.9.0 and accepts 4.9.0', () => {
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        expect(() => installHook(installOpts({ baselineRegistryVersion: '4.8.1' })))
+            .toThrow("Cursor hooks require baseline registry >= 4.9.0; installed is 4.8.1. Run 'awm update -y'.");
+        expect(fs_1.default.existsSync(hooksJson)).toBe(false);
+        expect(installHook(installOpts({ baselineRegistryVersion: '4.9.0' })).status).toBe('installed');
+    });
+    it('shouldDisableDeferredReanchor follows R16.2 thresholds', () => {
+        const { shouldDisableDeferredReanchor } = require('../../../src/commands/hooks/cursor');
+        expect(shouldDisableDeferredReanchor({ deliveryVerified: false, p95Ms: 10 })).toBe(true);
+        expect(shouldDisableDeferredReanchor({ deliveryVerified: true, p95Ms: 51 })).toBe(true);
+        expect(shouldDisableDeferredReanchor({ deliveryVerified: true, p95Ms: 50 })).toBe(false);
+    });
+    it('omits deferred events when disableDeferredReanchor is set', () => {
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        installHook(installOpts({ disableDeferredReanchor: true }));
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg.hooks.sessionStart).toEqual([{ command: path_1.default.join(cursorScriptsDir, 'session-start') }]);
+        expect(cfg.hooks.preCompact).toBeUndefined();
+        expect(cfg.hooks.postToolUse).toBeUndefined();
+        expect(fs_1.default.existsSync(path_1.default.join(cursorScriptsDir, 'session-start'))).toBe(true);
+        expect(fs_1.default.existsSync(path_1.default.join(cursorScriptsDir, 'pre-compact'))).toBe(false);
+    });
+    it('uninstall removes only AWM Cursor entries', () => {
+        writeRegistry();
+        const { installHook } = require('../../../src/commands/hooks/install');
+        const { uninstallHook } = require('../../../src/commands/hooks/uninstall');
+        installHook(installOpts());
+        const current = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        current.hooks.sessionStart.unshift({ command: '/user/keep' });
+        fs_1.default.writeFileSync(hooksJson, JSON.stringify(current, null, 2));
+        const result = uninstallHook({ agent: 'cursor' });
+        expect(result.status).toBe('uninstalled');
+        const cfg = JSON.parse(fs_1.default.readFileSync(hooksJson, 'utf8'));
+        expect(cfg.hooks.sessionStart).toEqual([{ command: '/user/keep' }]);
+        expect(cfg.hooks.preCompact).toBeUndefined();
+        expect(cfg.hooks.postToolUse).toBeUndefined();
+    });
+});

package/dist/tests/commands/hooks/resync.test.js

@@ -65,6 +65,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         const settings = JSON.parse(fs_1.default.readFileSync(path_1.default.join(tmpHome, '.claude/settings.json'), 'utf8'));
         expect(settings.hooks.SubagentStart[0].hooks[0].command).toBe('awm model-policy hook-event --event start');
@@ -85,6 +86,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'not-installed' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.awm/hooks/session-start'))).toBe(false);
     });
@@ -117,6 +119,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.lstatSync(skillDest).isSymbolicLink()).toBe(false);
         const content = fs_1.default.readFileSync(skillDest, 'utf-8');
@@ -135,6 +138,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.lstatSync(path_1.default.join(scriptsDir, 'session-start')).isSymbolicLink()).toBe(true);
         // Task 6: using-awm.md is materialized regardless of the scripts' install method —
@@ -151,6 +155,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'registry-missing' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8')).toContain('OLD');
     });
@@ -166,6 +171,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'resynced' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.existsSync(path_1.default.join(scriptsDir, 'session-start'))).toBe(true);
         // detectInstallMethod fell back to copy since lstatSync threw
@@ -189,6 +195,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'registry-missing' },
             { agent: 'codex', action: 'not-installed' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         // old script left intact — never leave user without hook
         expect(fs_1.default.readFileSync(path_1.default.join(scriptsDir, 'session-start'), 'utf-8')).toContain('OLD');
@@ -219,6 +226,7 @@ describe('resyncInstalledHooks', () => {
         expect(results).toEqual([
             { agent: 'claude-code', action: 'not-installed' },
             { agent: 'codex', action: 'resynced' },
+            { agent: 'cursor', action: 'not-installed' },
         ]);
         expect(fs_1.default.readFileSync(path_1.default.join(codexScriptsDir, 'session-start'), 'utf-8')).toContain('NEW CODEX');
     });

package/dist/tests/commands/init.test.js

@@ -395,20 +395,22 @@ describe('runInit', () => {
         expect(JSON.parse(fs_1.default.readFileSync(settingsPath, 'utf8'))).toEqual({ pristine: true, unrelated: 'keep' });
     });
     // -----------------------------------------------------------------------
-    // Gap A (QA panel) — GLOBAL-scope render pipeline for Cursor/Copilot was
-    // only ever exercised via LOCAL-scope `awm add`/bundle-install tests
-    // (tests/core/bundle-install.test.ts). This drives a real `awm init
-    // --agent cursor` through the REAL installBundle/applyInstallPlan path
-    // (no installBundle override — only syncCache is stubbed, to avoid a
-    // real network clone) and asserts a real rendered .mdc file lands in the
-    // GLOBAL ~/.cursor/rules directory with the expected frontmatter shape.
+    // Gap A (QA panel) — GLOBAL-scope Cursor skill delivery. Plan B installs
+    // Cursor skills as links under ~/.agents/skills (shared with Codex/
+    // OpenCode) plus native hooks.json entries (registry floor >= 4.9.0).
+    // Drives a real `awm init --agent cursor` through installBundle/
+    // applyInstallPlan (only syncCache stubbed) and asserts the link + hooks.
     // -----------------------------------------------------------------------
-    it('Gap A — real global-scope render: awm init --agent cursor renders a real .mdc into ~/.cursor/rules', async () => {
+    it('Gap A — real global-scope link: awm init --agent cursor links using-awm into ~/.agents/skills', async () => {
+        const { spawnSync } = require('child_process');
         const contentRoot = path_1.default.join(process.env.AWM_HOME, 'registries', 'baseline');
-        // A 'hooks' dir (even empty) is what makes capabilityRoot('hooks') resolve to
-        // this content root — that's the registryRoot stepContextInjection uses to
-        // find skills/using-awm/SKILL.md for the (unrelated) context-injection step.
+        // A 'hooks' dir is what makes capabilityRoot('hooks') resolve to this content
+        // root — registryRoot for stepContextInjection / stepHook. Plan B also needs
+        // the three Cursor hook scripts and an exact v4.9.0+ tag for the registry floor.
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'hooks'), { recursive: true });
+        for (const name of ['cursor-session-start', 'cursor-pre-compact', 'cursor-post-tool-use']) {
+            fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'hooks', name), '#!/usr/bin/env node\nconsole.log("{}")\n', { mode: 0o755 });
+        }
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'skills', 'using-awm'), { recursive: true });
         fs_1.default.writeFileSync(path_1.default.join(contentRoot, 'skills', 'using-awm', 'SKILL.md'), '---\nname: using-awm\ndescription: Use when starting any development conversation\n---\n\nMUST invoke skills per the tiered policy.\n');
         fs_1.default.mkdirSync(path_1.default.join(contentRoot, 'bundles', 'dev-core'), { recursive: true });
@@ -420,6 +422,10 @@ describe('runInit', () => {
             name: 'dev-core', version: '1.0.0', description: 'Baseline', scope: 'baseline',
             dependsOn: [], skills: ['using-awm'], workflows: [], agents: [],
         }));
+        spawnSync('git', ['init', '-q', '-b', 'main'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'add', '.'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['-c', 'user.email=t@t.t', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '-qm', 'fixture'], { cwd: contentRoot, stdio: 'ignore' });
+        spawnSync('git', ['tag', 'v4.9.0'], { cwd: contentRoot, stdio: 'ignore' });
         const projectCwd = fs_1.default.mkdtempSync(path_1.default.join(os_1.default.tmpdir(), 'awm-init-cursor-cwd-'));
         try {
             const { runInit } = require('../../src/commands/init');
@@ -431,20 +437,15 @@ describe('runInit', () => {
                 // seedBaselineRegistry() writes registries.json pointing at 'baseline'
                 // (our manually-seeded content root above) since none exists yet — no
                 // real network clone happens because that content root already exists
-                // on disk. Only syncCache is stubbed, so stepCache's own sync (the
-                // content root above has no `.git`, so it reads as "not yet cloned")
-                // doesn't try to shell out to git either.
+                // on disk. Only syncCache is stubbed.
                 actions: { syncCache: async () => { } },
             });
             expect(code).toBeLessThanOrEqual(1);
-            const mdcPath = path_1.default.join(tmpHome, '.cursor', 'rules', 'using-awm.mdc');
-            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor', 'rules', 'using-awm'))).toBe(false);
-            expect(fs_1.default.existsSync(mdcPath)).toBe(true);
-            const rendered = fs_1.default.readFileSync(mdcPath, 'utf8');
-            expect(rendered).toContain('description: Use when starting any development conversation');
-            expect(rendered).toContain('globs:');
-            expect(rendered).toContain('alwaysApply: false');
-            expect(rendered).toContain('MUST invoke skills per the tiered policy.');
+            const linked = path_1.default.join(tmpHome, '.agents', 'skills', 'using-awm');
+            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor', 'rules', 'using-awm.mdc'))).toBe(false);
+            expect(fs_1.default.lstatSync(linked).isSymbolicLink() || fs_1.default.existsSync(path_1.default.join(linked, 'SKILL.md'))).toBe(true);
+            expect(fs_1.default.readFileSync(path_1.default.join(linked, 'SKILL.md'), 'utf8')).toContain('MUST invoke skills per the tiered policy.');
+            expect(fs_1.default.existsSync(path_1.default.join(tmpHome, '.cursor', 'hooks.json'))).toBe(true);
         }
         finally {
             fs_1.default.rmSync(projectCwd, { recursive: true, force: true });