agentic-workflow-manager 9.14.0 → 9.15.0

package/dist/src/core/admission/registry-contracts.js

@@ -271,6 +271,17 @@ function hasOwnedGenerationAdmission(input) {
         || (generation.wrapperRef !== undefined && generation.wrapperRef.spawnNonce === generation.spawnNonce
             && (0, process_1.refIsAlive)(generation.wrapperRef));
 }
+/** R8: only a content registry (its manifest at the sensor project root) may close on a deliberate opt-out. */
+function registryOptOutPolicy(sensors) {
+    if (sensors?.mode !== 'opt-out' || !sensors.projectRoot)
+        return undefined;
+    try {
+        return fs_1.default.statSync(path_1.default.join(sensors.projectRoot, registries_1.REGISTRY_MANIFEST_NAME)).isFile() ? 'r8-registry-opt-out' : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /** One admission authority for the public command AND actual watch dispatch.
  * No empirical execution occurs before provenance/currentness/CLI-floor gates. */
 async function admitRegistryPlan(input, dependencies = {}) {
@@ -308,8 +319,9 @@ async function admitRegistryPlan(input, dependencies = {}) {
         return scope.provenance === 'proven';
     };
     let generationBound = false;
+    let sensorClosurePolicy;
     const compose = async (fields) => {
-        const report = await admission({ ...input, provenance: scope.provenance, consumedRegistryComponents: scope.consumedRegistryComponents, ...fields });
+        const report = await admission({ ...input, provenance: scope.provenance, consumedRegistryComponents: scope.consumedRegistryComponents, ...(sensorClosurePolicy ? { sensorClosurePolicy } : {}), ...fields });
         const withEvidence = generationBound && report.sensors === 'pass' ? { ...report, sensorEvidence: 'generation-bound' } : report;
         if (scope.provenanceDiagnostic && report.diagnostics.some(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED')) {
             return { ...withEvidence, diagnostics: report.diagnostics.map(diagnostic => diagnostic.code === 'ADMISSION_CURRENTNESS_PROVENANCE_REQUIRED' ? scope.provenanceDiagnostic : diagnostic) };
@@ -337,6 +349,7 @@ async function admitRegistryPlan(input, dependencies = {}) {
     const sensors = input.verifySensors ? input.sensors ?? (generationBound
         ? { sensors: [], overall: 'pass', reason: 'generation-bound-admission' }
         : await (dependencies.runSensors ?? run_1.runSensors)({ cwd: input.cwd, all: true, readOnly: true })) : undefined;
+    sensorClosurePolicy = registryOptOutPolicy(sensors);
     if (input.requireCurrent && input.verifySensors) {
         if (!refresh())
             return compose({ currentness, sensors });

package/dist/src/core/context/strategies/codex-agents.js

@@ -52,8 +52,11 @@ class CodexAgentsStrategy {
         if (!fs_1.default.existsSync(input.ref.absPath)) {
             throw new Error(`materialized context not found at ${input.ref.absPath}`);
         }
+        // Cursor: using-awm moves to the sessionStart hook (Plan B S2); project AGENTS.md
+        // carries PROJECT_GUIDANCE only (R4/R10). Copilot stays the sole full-context carrier.
         const markdown = fs_1.default.readFileSync(input.ref.absPath, 'utf8');
-        return injectFile(this.targetFile(provider, scope, input.projectRoot), withProjectGuidance(markdown, scope));
+        const body = input.agent === 'cursor' ? PROJECT_GUIDANCE : withProjectGuidance(markdown, scope);
+        return injectFile(this.targetFile(provider, scope, input.projectRoot), body);
     }
     remove(input, provider) {
         const scope = this.assertSupportedScope(input, provider);
@@ -78,7 +81,8 @@ class CodexAgentsStrategy {
         const expected = fs_1.default.readFileSync(input.ref.absPath, 'utf8');
         if ((0, provider_1.sha256)(expected) !== input.ref.contentHash)
             return 'stale';
-        return body === (0, managed_block_1.normalizeManagedBody)(withProjectGuidance(expected, scope)) ? 'injected' : 'stale';
+        const expectedBody = input.agent === 'cursor' ? PROJECT_GUIDANCE : withProjectGuidance(expected, scope);
+        return body === (0, managed_block_1.normalizeManagedBody)(expectedBody) ? 'injected' : 'stale';
     }
     injectGlobal(context, provider) {
         if (typeof context !== 'object' || context === null) {

package/dist/src/core/cursor-budgets.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CURSOR_REANCHOR_PIN = exports.CURSOR_SESSION_START_PIN = exports.CURSOR_REANCHOR_MAX_BYTES = exports.CURSOR_SESSION_START_MAX_BYTES = void 0;
+/** Cursor hook payload caps (Plan A / Plan B R5). Must match baseline registry scripts. */
+exports.CURSOR_SESSION_START_MAX_BYTES = 24 * 1024;
+exports.CURSOR_REANCHOR_MAX_BYTES = 4 * 1024;
+exports.CURSOR_SESSION_START_PIN = 'cursor.sessionStartMaxBytes';
+exports.CURSOR_REANCHOR_PIN = 'cursor.reanchorMaxBytes';

package/dist/src/core/dashboard/sanitize.js

@@ -15,9 +15,9 @@ const CANONICAL_FINDING_IDS = new Set([
     'machine.preferences.missing', 'machine.registries.stale', 'project.profile.missing',
     'project.sensors.unavailable', 'project.preflight.degraded', 'planning.source.unavailable', 'execution.source.unavailable',
 ]);
-const PROVIDER_FINDING_ID = /^machine\.provider\.(?:claude-code|codex|opencode|cursor|copilot|antigravity)\.(?:binary\.version|skills\.global|agents\.native|workflows\.global|context\.global|hook\.trust|guidance\.project|constitution\.delivery)$/;
+const PROVIDER_FINDING_ID = /^machine\.provider\.(?:claude-code|codex|opencode|cursor|copilot|antigravity)\.(?:binary\.version|skills\.global|agents\.native|workflows\.global|context\.global|context\.overlap|hook\.trust|guidance\.project|constitution\.delivery)$/;
 const PROJECT_FINDING_ID = /^project\.(?:profile\.present|extensions\.configured|registry-pins\.present|bundles\.coherent|context\.present|constitution\.present|sensors\.present|preflight\.not_collected)$/;
-const PROVIDER_LABEL = /^Provider (?:claude-code|codex|opencode|cursor|copilot|antigravity): (?:binary\.version|skills\.global|agents\.native|workflows\.global|context\.global|hook\.trust|guidance\.project|constitution\.delivery)$/;
+const PROVIDER_LABEL = /^Provider (?:claude-code|codex|opencode|cursor|copilot|antigravity): (?:binary\.version|skills\.global|agents\.native|workflows\.global|context\.global|context\.overlap|hook\.trust|guidance\.project|constitution\.delivery)$/;
 // El slug ya lo validó PROCESS_NAME en core/process/model.ts. Repetir la forma
 // acá es deliberado: este módulo es la frontera de render y no puede confiar en
 // que su input pasó por aquel validador — un adapter nuevo podría no hacerlo.

package/dist/src/core/diagnostics/provider-checks.js

@@ -375,11 +375,12 @@ function hookTrustCheck(agent) {
         return { id: 'hook.trust', state: 'absent', remediationCode: 'awm-init' };
     }
     if (status.trust) {
-        // Codex: 'pending-trust' | 'healthy' | 'stale' map directly onto ProviderCheckState.
+        // Codex: 'pending-trust' | 'healthy' | 'stale'; Cursor: 'pending-first-run' | …
         return {
             id: 'hook.trust',
             state: status.trust,
-            remediationCode: status.trust === 'pending-trust' ? 'open-hooks-trust' : undefined,
+            remediationCode: status.trust === 'pending-trust' ? 'open-hooks-trust'
+                : status.trust === 'pending-first-run' ? 'open-cursor-session' : undefined,
         };
     }
     return { id: 'hook.trust', state: status.overall === 'HEALTHY' ? 'healthy' : 'broken' };
@@ -470,6 +471,14 @@ function gatherProviderChecks(agents, scanSkills, projectRoot) {
             hookTrustCheck(agent),
             contextGlobalCheck(agent, projectRoot),
         ].filter((check) => check !== null);
+        // R19: informational only — never overall-red by itself (state: pending).
+        if (agent === 'cursor' && agents.includes('claude-code') && agents.includes('cursor')) {
+            checks.push({
+                id: 'context.overlap',
+                state: 'pending',
+                detail: 'Claude Code may import Cursor hooks as a third-party path; R15 dual-delivery suppression requires the Cursor session-start hook installed',
+            });
+        }
         return { id: agent, label: provider.label, tier: providerTier(provider), checks };
     });
 }

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();
+    });
+});